Field3D
MACField.h
Go to the documentation of this file.
1//----------------------------------------------------------------------------//
2
3/*
4 * Copyright (c) 2009 Sony Pictures Imageworks Inc
5 *
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the
17 * distribution. Neither the name of Sony Pictures Imageworks nor the
18 * names of its contributors may be used to endorse or promote
19 * products derived from this software without specific prior written
20 * permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
33 * OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35
36//----------------------------------------------------------------------------//
37
42//----------------------------------------------------------------------------//
43
44#ifndef _INCLUDED_Field3D_MACField_H_
45#define _INCLUDED_Field3D_MACField_H_
46
47#include <vector>
48#include <boost/lexical_cast.hpp>
49
50#include "Field.h"
51
52//----------------------------------------------------------------------------//
53
54#include "ns.h"
55
57
58//----------------------------------------------------------------------------//
59// Forward declarations
60//----------------------------------------------------------------------------//
61
62template <class T>
64template <class T>
66
67//----------------------------------------------------------------------------//
68// Enumerators
69//----------------------------------------------------------------------------//
70
76
77//----------------------------------------------------------------------------//
78// MACField
79//----------------------------------------------------------------------------//
80
92//----------------------------------------------------------------------------//
93
94template <class Data_T>
95class MACField : public ResizableField<Data_T>
96{
97public:
98
99 // Typedefs ------------------------------------------------------------------
100
101 typedef boost::intrusive_ptr<MACField> Ptr;
102 typedef std::vector<Ptr> Vec;
103
105 typedef typename Data_T::BaseType real_t;
106
109
110 // RTTI replacement ----------------------------------------------------------
111
114
115 static const char *staticClassName()
116 {
117 return "MACField";
118 }
119
120 static const char* staticClassType()
121 {
123 }
124
125 // Constructors --------------------------------------------------------------
126
129
131 MACField();
132
133 // \}
134
135 // Main methods --------------------------------------------------------------
136
138 virtual void clear(const Data_T &value);
139
140 // From Field base class -----------------------------------------------------
141
144
146 virtual Data_T value(int i, int j, int k) const;
147 virtual long long int memSize() const;
148
150
151 // From WritableField base class ---------------------------------------------
152
155
159 virtual Data_T& lvalue(int i, int j, int k);
160
162
163 // Concrete component access -------------------------------------------------
164
167
170 const real_t& u(int i, int j, int k) const;
173 real_t& u(int i, int j, int k);
176 const real_t& v(int i, int j, int k) const;
179 real_t& v(int i, int j, int k);
182 const real_t& w(int i, int j, int k) const;
185 real_t& w(int i, int j, int k);
186
188
189 // Iterators -----------------------------------------------------------------
190
200
202 class const_mac_comp_iterator;
204 class mac_comp_iterator;
205
207 const_mac_comp_iterator cbegin_comp(MACComponent comp) const;
209 const_mac_comp_iterator cbegin_comp(MACComponent comp,
210 const Box3i &subset) const;
212 const_mac_comp_iterator cend_comp(MACComponent comp) const;
214 const_mac_comp_iterator cend_comp(MACComponent comp,
215 const Box3i &subset) const;
216
218 mac_comp_iterator begin_comp(MACComponent comp);
220 mac_comp_iterator begin_comp(MACComponent comp,
221 const Box3i &subset);
223 mac_comp_iterator end_comp(MACComponent comp);
225 mac_comp_iterator end_comp(MACComponent comp,
226 const Box3i &subset);
227
229
230 // Utility methods -----------------------------------------------------------
231
233 real_t uCenter(int i, int j, int k) const
234 {
235 return (u(i, j, k) + u(i + 1, j, k)) * 0.5;
236 }
238 real_t vCenter(int i, int j, int k) const
239 {
240 return (v(i, j, k) + v(i, j + 1, k)) * 0.5;
241 }
243 real_t wCenter(int i, int j, int k) const
244 {
245 return (w(i, j, k) + w(i, j, k + 1)) * 0.5;
246 }
247
251 {
253 std::copy(other->m_u.begin(), other->m_u.end(), m_u.begin());
254 std::copy(other->m_v.begin(), other->m_v.end(), m_v.begin());
255 std::copy(other->m_w.begin(), other->m_w.end(), m_w.begin());
256 }
257
258 // Utility methods -----------------------------------------------------------
259
262 { return V3i((int)m_u.size(), (int)m_v.size(), (int)m_w.size()); }
263
264 // From FieldBase ------------------------------------------------------------
265
268
270
271 virtual FieldBase::Ptr clone() const
272 { return Ptr(new MACField(*this)); }
273
275
276 protected:
277
278 // From ResizableField class ---------------------------------------------
279
280 virtual void sizeChanged();
281
282 // Concrete component access -------------------------------------------------
283
286 const real_t* uPtr(int i, int j, int k) const;
289 real_t* uPtr(int i, int j, int k);
292 const real_t* vPtr(int i, int j, int k) const;
295 real_t* vPtr(int i, int j, int k);
298 const real_t* wPtr(int i, int j, int k) const;
301 real_t* wPtr(int i, int j, int k);
302
303 // Data members --------------------------------------------------------------
304
306 std::vector<real_t> m_u;
308 std::vector<real_t> m_v;
310 std::vector<real_t> m_w;
311
324
326 mutable Data_T m_dummy;
327
328private:
329
330 // Static data members -------------------------------------------------------
331
333
334 // Typedefs ------------------------------------------------------------------
335
337
338};
339
340//----------------------------------------------------------------------------//
341// Static member instantiation
342//----------------------------------------------------------------------------//
343
345
346//----------------------------------------------------------------------------//
347// Typedefs
348//----------------------------------------------------------------------------//
349
353
354//----------------------------------------------------------------------------//
355// MACField::const_mac_comp_iterator
356//----------------------------------------------------------------------------//
357
358template <class Data_T>
360{
361public:
362
363 // Typedefs ------------------------------------------------------------------
364
367
368 // Constructors --------------------------------------------------------------
369
371 const class_type &field,
372 const Box3i &window,
373 const V3i &currentPos)
374 : x(currentPos.x), y(currentPos.y), z(currentPos.z),
375 m_p(NULL), m_window(window), m_comp(comp),
376 m_field(field)
377 {
378 if (window.intersects(currentPos))
379 updatePointer();
380 }
381
382 // Operators -----------------------------------------------------------------
383
384 const const_mac_comp_iterator& operator ++ ()
385 {
386 if (x == m_window.max.x) {
387 if (y == m_window.max.y) {
388 if (z == m_window.max.z) {
389 m_p = 0;
390 return *this;
391 } else {
392 x = m_window.min.x;
393 y = m_window.min.y;
394 ++z;
395 }
396 } else {
397 x = m_window.min.x;
398 ++y;
399 }
400 updatePointer();
401 } else {
402 ++x;
403 ++m_p;
404 }
405 return *this;
406 }
407
408 template <class Iter_T>
409 inline bool operator == (const Iter_T &rhs) const
410 {
411 return m_p == &(*rhs);
412 }
413
414 template <class Iter_T>
415 inline bool operator != (const Iter_T &rhs) const
416 {
417 return m_p != &(*rhs);
418 }
419
420 inline const real_t& operator * () const
421 {
422 return *m_p;
423 }
424
425 inline const real_t* operator -> () const
426 {
427 return m_p;
428 }
429
430 // Public data members -------------------------------------------------------
431
433 int x, y, z;
434
435private:
436
437 // Convenience methods -------------------------------------------------------
438
440 {
441 switch (m_comp) {
442 case MACCompU:
443 m_p = m_field.uPtr(x, y, z);
444 break;
445 case MACCompV:
446 m_p = m_field.vPtr(x, y, z);
447 break;
448 case MACCompW:
449 m_p = m_field.wPtr(x, y, z);
450 break;
451 default:
452 assert(false && "Illegal MACComponent in const_mac_comp_iterator");
453 }
454 }
455
456 // Private data members ------------------------------------------------------
457
459 const real_t *m_p;
466
467};
468
469//----------------------------------------------------------------------------//
470
471template <class Data_T>
473{
474public:
475
476 // Typedefs ------------------------------------------------------------------
477
480
481 // Constructors --------------------------------------------------------------
482
484 const Box3i &window, const V3i &currentPos)
485 : x(currentPos.x), y(currentPos.y), z(currentPos.z),
486 m_p(NULL), m_window(window), m_comp(comp),
487 m_field(field)
488 {
489 if (window.intersects(currentPos))
490 updatePointer();
491 }
492
493 // Operators -----------------------------------------------------------------
494
495 mac_comp_iterator& operator ++ ()
496 {
497 if (x == m_window.max.x) {
498 if (y == m_window.max.y) {
499 if (z == m_window.max.z) {
500 m_p = 0;
501 return *this;
502 } else {
503 x = m_window.min.x;
504 y = m_window.min.y;
505 ++z;
506 }
507 } else {
508 x = m_window.min.x;
509 ++y;
510 }
511 updatePointer();
512 } else {
513 ++x;
514 ++m_p;
515 }
516 return *this;
517 }
518
519 template <class Iter_T>
520 inline bool operator == (const Iter_T &rhs) const
521 {
522 return m_p == &(*rhs);
523 }
524
525 template <class Iter_T>
526 inline bool operator != (const Iter_T &rhs) const
527 {
528 return m_p != &(*rhs);
529 }
530
531 inline real_t& operator * () const
532 {
533 return *m_p;
534 }
535
536 inline real_t* operator -> () const
537 {
538 return m_p;
539 }
540
541 // Public data members -------------------------------------------------------
542
544 int x, y, z;
545
546private:
547
548 // Convenience methods -------------------------------------------------------
549
551 {
552 switch (m_comp) {
553 case MACCompU:
554 m_p = m_field.uPtr(x, y, z);
555 break;
556 case MACCompV:
557 m_p = m_field.vPtr(x, y, z);
558 break;
559 case MACCompW:
560 m_p = m_field.wPtr(x, y, z);
561 break;
562 default:
563 assert(false && "Illegal MACComponent in const_mac_comp_iterator");
564 }
565 }
566
567 // Private data members ------------------------------------------------------
568
577
578};
579
580//----------------------------------------------------------------------------//
581// Implementation specific helpers
582//----------------------------------------------------------------------------//
583
584namespace MACFieldUtil {
585
587 {
588 switch (comp) {
589 case MACCompU:
590 dataWindow.max += V3i(1, 0, 0);
591 break;
592 case MACCompV:
593 dataWindow.max += V3i(0, 1, 0);
594 break;
595 case MACCompW:
596 dataWindow.max += V3i(0, 0, 1);
597 break;
598 default:
599 assert(false && "Illegal MACComponent in makeDataWindowForComponent");
600 }
601 return dataWindow;
602 }
603
604}
605
606//----------------------------------------------------------------------------//
607// MACField implementations
608//----------------------------------------------------------------------------//
609
610template <class Data_T>
612 : base()
613{
614
615}
616
617//----------------------------------------------------------------------------//
618
619template <class Data_T>
620inline void MACField<Data_T>::clear(const Data_T &value)
621{
622 std::fill(m_u.begin(), m_u.end(), value.x);
623 std::fill(m_v.begin(), m_v.end(), value.y);
624 std::fill(m_w.begin(), m_w.end(), value.z);
625}
626
627//----------------------------------------------------------------------------//
628
629template <class Data_T>
630Data_T MACField<Data_T>::value(int i, int j, int k) const
631{
632 return Data_T(uCenter(i, j, k), vCenter(i, j, k), wCenter(i, j, k));
633}
634
635//----------------------------------------------------------------------------//
636
637template <class Data_T>
638long long int MACField<Data_T>::memSize() const
639{
640 long long int superClassMemSize = base::memSize();
641 long long int vectorMemSize =
642 (m_u.capacity() + m_v.capacity() + m_w.capacity()) * sizeof(real_t);
643 return sizeof(*this) + vectorMemSize + superClassMemSize;
644}
645
646//----------------------------------------------------------------------------//
647
648template <class Data_T>
649Data_T& MACField<Data_T>::lvalue(int i, int j, int k)
650{
651 m_dummy = value(i, j, k);
652 return m_dummy;
653}
654
655//----------------------------------------------------------------------------//
656
657template <class Data_T>
659{
660 // Call base class
661 base::sizeChanged();
662
663 V3i baseSize =
664 base::m_dataWindow.max - base::m_dataWindow.min + V3i(1);
665
666 if (std::min(std::min(baseSize.x, baseSize.y), baseSize.z) < 0)
667 throw Exc::ResizeException("Attempt to resize ResizableField object "
668 "using negative size. Data window was: " +
669 boost::lexical_cast<std::string>(baseSize));
670
671 // Calculate the size for each component of the MAC field
672 m_uSize = baseSize + V3i(1, 0, 0);
673 m_vSize = baseSize + V3i(0, 1, 0);
674 m_wSize = baseSize + V3i(0, 0, 1);
675
676 // Calculate the size of each z slice
677 m_uSizeXY = m_uSize.x * m_uSize.y;
678 m_vSizeXY = m_vSize.x * m_vSize.y;
679 m_wSizeXY = m_wSize.x * m_wSize.y;
680
681 // Allocate memory
682 try {
683 m_u.resize(m_uSize.x * m_uSize.y * m_uSize.z);
684 m_v.resize(m_vSize.x * m_vSize.y * m_vSize.z);
685 m_w.resize(m_wSize.x * m_wSize.y * m_wSize.z);
686 }
687 catch (std::bad_alloc &) {
688 throw Exc::MemoryException("Couldn't allocate MACField of size " +
689 boost::lexical_cast<std::string>(baseSize));
690 }
691
692}
693
694//----------------------------------------------------------------------------//
695
696template <class Data_T>
697inline const typename MACField<Data_T>::real_t&
698MACField<Data_T>::u(int i, int j, int k) const
699{
700 assert (i >= base::m_dataWindow.min.x);
701 assert (i <= base::m_dataWindow.max.x + 1);
702 assert (j >= base::m_dataWindow.min.y);
703 assert (j <= base::m_dataWindow.max.y);
704 assert (k >= base::m_dataWindow.min.z);
705 assert (k <= base::m_dataWindow.max.z);
706 // Add crop window offset
707 i -= base::m_dataWindow.min.x;
708 j -= base::m_dataWindow.min.y;
709 k -= base::m_dataWindow.min.z;
710 return m_u[i + j * m_uSize.x + k * m_uSizeXY];
711}
712
713//----------------------------------------------------------------------------//
714
715template <class Data_T>
716inline typename MACField<Data_T>::real_t&
717MACField<Data_T>::u(int i, int j, int k)
718{
719 assert (i >= base::m_dataWindow.min.x);
720 assert (i <= base::m_dataWindow.max.x + 1);
721 assert (j >= base::m_dataWindow.min.y);
722 assert (j <= base::m_dataWindow.max.y);
723 assert (k >= base::m_dataWindow.min.z);
724 assert (k <= base::m_dataWindow.max.z);
725 // Add crop window offset
726 i -= base::m_dataWindow.min.x;
727 j -= base::m_dataWindow.min.y;
728 k -= base::m_dataWindow.min.z;
729 return m_u[i + j * m_uSize.x + k * m_uSizeXY];
730}
731
732//----------------------------------------------------------------------------//
733
734template <class Data_T>
735inline const typename MACField<Data_T>::real_t&
736MACField<Data_T>::v(int i, int j, int k) const
737{
738 assert (i >= base::m_dataWindow.min.x);
739 assert (i <= base::m_dataWindow.max.x);
740 assert (j >= base::m_dataWindow.min.y);
741 assert (j <= base::m_dataWindow.max.y + 1);
742 assert (k >= base::m_dataWindow.min.z);
743 assert (k <= base::m_dataWindow.max.z);
744 // Add crop window offset
745 i -= base::m_dataWindow.min.x;
746 j -= base::m_dataWindow.min.y;
747 k -= base::m_dataWindow.min.z;
748 return m_v[i + j * m_vSize.x + k * m_vSizeXY];
749}
750
751//----------------------------------------------------------------------------//
752
753template <class Data_T>
754inline typename MACField<Data_T>::real_t&
755MACField<Data_T>::v(int i, int j, int k)
756{
757 assert (i >= base::m_dataWindow.min.x);
758 assert (i <= base::m_dataWindow.max.x);
759 assert (j >= base::m_dataWindow.min.y);
760 assert (j <= base::m_dataWindow.max.y + 1);
761 assert (k >= base::m_dataWindow.min.z);
762 assert (k <= base::m_dataWindow.max.z);
763 // Add crop window offset
764 i -= base::m_dataWindow.min.x;
765 j -= base::m_dataWindow.min.y;
766 k -= base::m_dataWindow.min.z;
767 return m_v[i + j * m_vSize.x + k * m_vSizeXY];
768}
769
770//----------------------------------------------------------------------------//
771
772template <class Data_T>
773inline const typename MACField<Data_T>::real_t&
774MACField<Data_T>::w(int i, int j, int k) const
775{
776 assert (i >= base::m_dataWindow.min.x);
777 assert (i <= base::m_dataWindow.max.x);
778 assert (j >= base::m_dataWindow.min.y);
779 assert (j <= base::m_dataWindow.max.y);
780 assert (k >= base::m_dataWindow.min.z);
781 assert (k <= base::m_dataWindow.max.z + 1);
782 // Add crop window offset
783 i -= base::m_dataWindow.min.x;
784 j -= base::m_dataWindow.min.y;
785 k -= base::m_dataWindow.min.z;
786 return m_w[i + j * m_wSize.x + k * m_wSizeXY];
787}
788
789//----------------------------------------------------------------------------//
790
791template <class Data_T>
792inline typename MACField<Data_T>::real_t&
793MACField<Data_T>::w(int i, int j, int k)
794{
795 assert (i >= base::m_dataWindow.min.x);
796 assert (i <= base::m_dataWindow.max.x);
797 assert (j >= base::m_dataWindow.min.y);
798 assert (j <= base::m_dataWindow.max.y);
799 assert (k >= base::m_dataWindow.min.z);
800 assert (k <= base::m_dataWindow.max.z + 1);
801 // Add crop window offset
802 i -= base::m_dataWindow.min.x;
803 j -= base::m_dataWindow.min.y;
804 k -= base::m_dataWindow.min.z;
805 return m_w[i + j * m_wSize.x + k * m_wSizeXY];
806}
807
808//----------------------------------------------------------------------------//
809
810template <class Data_T>
813{
814 using namespace MACFieldUtil;
815 if (FieldRes::dataResolution() == V3i(0))
816 return cend_comp(comp);
817 Box3i dataWindow =
818 makeDataWindowForComponent(base::m_dataWindow, comp);
819 return const_mac_comp_iterator(comp, *this, dataWindow, dataWindow.min);
820}
821
822//----------------------------------------------------------------------------//
823
824template <class Data_T>
827{
828 using namespace MACFieldUtil;
829 if (subset.isEmpty())
830 return cend_comp(comp, subset);
831 Box3i dataWindow = makeDataWindowForComponent(subset, comp);
832 return const_mac_comp_iterator(comp, *this, dataWindow, subset.min);
833}
834
835//----------------------------------------------------------------------------//
836
837template <class Data_T>
840{
841 using namespace MACFieldUtil;
842 Box3i dataWindow =
843 makeDataWindowForComponent(base::m_dataWindow, comp);
844 return const_mac_comp_iterator(comp, *this, dataWindow,
845 V3i(dataWindow.min.x,
846 dataWindow.min.y,
847 dataWindow.max.z + 1));
848}
849
850//----------------------------------------------------------------------------//
851
852template <class Data_T>
855{
856 using namespace MACFieldUtil;
857 Box3i dataWindow = makeDataWindowForComponent(subset, comp);
858 return const_mac_comp_iterator(comp, *this, dataWindow,
859 V3i(dataWindow.min.x,
860 dataWindow.min.y,
861 dataWindow.max.z + 1));
862}
863
864//----------------------------------------------------------------------------//
865
866template <class Data_T>
869{
870 using namespace MACFieldUtil;
871 if (FieldRes::dataResolution() == V3i(0))
872 return end_comp(comp);
873 Box3i dataWindow = makeDataWindowForComponent(base::m_dataWindow, comp);
874 return mac_comp_iterator(comp, *this, dataWindow, dataWindow.min);
875}
876
877//----------------------------------------------------------------------------//
878
879template <class Data_T>
882{
883 using namespace MACFieldUtil;
884 if (subset.isEmpty())
885 return end_comp(comp, subset);
886 Box3i dataWindow = makeDataWindowForComponent(subset, comp);
887 return mac_comp_iterator(comp, *this, dataWindow, subset.min);
888}
889
890//----------------------------------------------------------------------------//
891
892template <class Data_T>
895{
896 using namespace MACFieldUtil;
897 Box3i dataWindow = makeDataWindowForComponent(base::m_dataWindow, comp);
898 return mac_comp_iterator(comp, *this, dataWindow, V3i(dataWindow.min.x,
899 dataWindow.min.y,
900 dataWindow.max.z + 1));
901}
902
903//----------------------------------------------------------------------------//
904
905template <class Data_T>
908{
909 using namespace MACFieldUtil;
910 Box3i dataWindow = makeDataWindowForComponent(subset, comp);
911 return mac_comp_iterator(comp, *this, dataWindow, V3i(dataWindow.min.x,
912 dataWindow.min.y,
913 dataWindow.max.z + 1));
914}
915
916//----------------------------------------------------------------------------//
917
918template <class Data_T>
919inline const typename MACField<Data_T>::real_t*
920MACField<Data_T>::uPtr(int i, int j, int k) const
921{
922 // Add crop window offset
923 i -= base::m_dataWindow.min.x;
924 j -= base::m_dataWindow.min.y;
925 k -= base::m_dataWindow.min.z;
926 return &m_u[i + j * m_uSize.x + k * m_uSizeXY];
927}
928
929//----------------------------------------------------------------------------//
930
931template <class Data_T>
932inline typename MACField<Data_T>::real_t*
934{
935 // Add crop window offset
936 i -= base::m_dataWindow.min.x;
937 j -= base::m_dataWindow.min.y;
938 k -= base::m_dataWindow.min.z;
939 return &m_u[i + j * m_uSize.x + k * m_uSizeXY];
940}
941
942//----------------------------------------------------------------------------//
943
944template <class Data_T>
945inline const typename MACField<Data_T>::real_t*
946MACField<Data_T>::vPtr(int i, int j, int k) const
947{
948 // Add crop window offset
949 i -= base::m_dataWindow.min.x;
950 j -= base::m_dataWindow.min.y;
951 k -= base::m_dataWindow.min.z;
952 return &m_v[i + j * m_vSize.x + k * m_vSizeXY];
953}
954
955//----------------------------------------------------------------------------//
956
957template <class Data_T>
958inline typename MACField<Data_T>::real_t*
960{
961 // Add crop window offset
962 i -= base::m_dataWindow.min.x;
963 j -= base::m_dataWindow.min.y;
964 k -= base::m_dataWindow.min.z;
965 return &m_v[i + j * m_vSize.x + k * m_vSizeXY];
966}
967
968//----------------------------------------------------------------------------//
969
970template <class Data_T>
971inline const typename MACField<Data_T>::real_t*
972MACField<Data_T>::wPtr(int i, int j, int k) const
973{
974 // Add crop window offset
975 i -= base::m_dataWindow.min.x;
976 j -= base::m_dataWindow.min.y;
977 k -= base::m_dataWindow.min.z;
978 return &m_w[i + j * m_wSize.x + k * m_wSizeXY];
979}
980
981//----------------------------------------------------------------------------//
982
983template <class Data_T>
984inline typename MACField<Data_T>::real_t*
986{
987 // Add crop window offset
988 i -= base::m_dataWindow.min.x;
989 j -= base::m_dataWindow.min.y;
990 k -= base::m_dataWindow.min.z;
991 return &m_w[i + j * m_wSize.x + k * m_wSizeXY];
992}
993
994//----------------------------------------------------------------------------//
995
997
998//----------------------------------------------------------------------------//
999
1000#endif // Include guard
FIELD3D_VEC3_T< T > operator*(S s, const FIELD3D_VEC3_T< T > vec)
Scalar times Vec3 multiplication. Makes the interpolation calls cleaner.
Contains Field, WritableField and ResizableField classes.
#define FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(field)
Definition Field.h:479
MACField< V3d > MACField3d
Definition MACField.h:352
MACField< V3f > MACField3f
Definition MACField.h:351
MACComponent
Definition MACField.h:71
@ MACCompV
Definition MACField.h:73
@ MACCompU
Definition MACField.h:72
@ MACCompW
Definition MACField.h:74
MACField< V3h > MACField3h
Definition MACField.h:350
Imath::V3i V3i
Definition SpiMathLib.h:71
Imath::Box3i Box3i
Definition SpiMathLib.h:77
#define FIELD3D_MTX_T
Definition StdMathLib.h:99
boost::intrusive_ptr< FieldBase > Ptr
Definition Field.h:97
std::string name
Optional name of the field.
Definition Field.h:171
V3i const dataResolution() const
Definition Field.h:256
MACComponent m_comp
Component to look up.
Definition MACField.h:463
MACField< Data_T > class_type
Definition MACField.h:365
const real_t * m_p
Pointer to current element.
Definition MACField.h:459
Box3i m_window
Window to traverse.
Definition MACField.h:461
const_mac_comp_iterator(MACComponent comp, const class_type &field, const Box3i &window, const V3i &currentPos)
Definition MACField.h:370
MACField< Data_T >::real_t real_t
Definition MACField.h:366
const class_type & m_field
Reference to field being iterated over.
Definition MACField.h:465
real_t * m_p
Pointer to current element.
Definition MACField.h:570
class_type & m_field
Reference to field being iterated over.
Definition MACField.h:576
MACComponent m_comp
Component to look up.
Definition MACField.h:574
mac_comp_iterator(MACComponent comp, class_type &field, const Box3i &window, const V3i &currentPos)
Definition MACField.h:483
int x
Current position.
Definition MACField.h:544
MACField< Data_T > class_type
Definition MACField.h:478
Box3i m_window
Window to traverse.
Definition MACField.h:572
MACField< Data_T >::real_t real_t
Definition MACField.h:479
This subclass of Field implements a standard MAC field. Refer to your favorite fluid simulations book...
Definition MACField.h:96
MACField< Data_T > class_type
Definition MACField.h:112
real_t vCenter(int i, int j, int k) const
Returns the v-component interpolated to the cell center.
Definition MACField.h:238
std::vector< real_t > m_u
U component storage.
Definition MACField.h:306
const real_t & w(int i, int j, int k) const
Read access to value on w-facing wall.
Definition MACField.h:774
static TemplatedFieldType< MACField< Data_T > > ms_classType
Definition MACField.h:332
ResizableField< Data_T > base
Definition MACField.h:336
Data_T::BaseType real_t
This typedef is used to refer to the scalar component type of the vectors.
Definition MACField.h:105
std::vector< Ptr > Vec
Definition MACField.h:102
MACField()
Constructs an empty buffer.
Definition MACField.h:611
int m_wSizeXY
Size of xy slice for w component.
Definition MACField.h:323
const real_t * uPtr(int i, int j, int k) const
Direct access to value on u-facing wall.
Definition MACField.h:920
int m_uSizeXY
Size of xy slice for u component.
Definition MACField.h:315
V3i m_wSize
Size of W grid along each axis.
Definition MACField.h:321
DEFINE_FIELD_RTTI_CONCRETE_CLASS
Definition MACField.h:113
const real_t * vPtr(int i, int j, int k) const
Direct access to value on v-facing wall.
Definition MACField.h:946
virtual void sizeChanged()
Subclasses should re-implement this if they need to perform memory allocations, etc....
Definition MACField.h:658
const real_t & u(int i, int j, int k) const
Read access to value on u-facing wall.
Definition MACField.h:698
V3i m_uSize
Size of U grid along each axis.
Definition MACField.h:313
LinearMACFieldInterp< Data_T > LinearInterp
Definition MACField.h:107
static const char * staticClassType()
Definition MACField.h:120
boost::intrusive_ptr< MACField > Ptr
Definition MACField.h:101
V3i m_vSize
Size of V grid along each axis.
Definition MACField.h:317
int m_vSizeXY
Size of xy slice for v component.
Definition MACField.h:319
virtual Data_T value(int i, int j, int k) const
Definition MACField.h:630
mac_comp_iterator end_comp(MACComponent comp)
Iterator to first element.
Definition MACField.h:894
Data_T m_dummy
Dummy storage of a temp value that lvalue() can write to.
Definition MACField.h:326
virtual FieldBase::Ptr clone() const
Returns a pointer to a copy of the field, pure virtual so ensure derived classes properly implement i...
Definition MACField.h:271
const real_t * wPtr(int i, int j, int k) const
Direct access to value on w-facing wall.
Definition MACField.h:972
CubicMACFieldInterp< Data_T > CubicInterp
Definition MACField.h:108
real_t uCenter(int i, int j, int k) const
Returns the u-component interpolated to the cell center.
Definition MACField.h:233
FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
Definition MACField.h:269
std::vector< real_t > m_v
V component storage.
Definition MACField.h:308
const real_t & v(int i, int j, int k) const
Read access to value on v-facing wall.
Definition MACField.h:736
const_mac_comp_iterator cend_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition MACField.h:839
virtual void clear(const Data_T &value)
Clears all the voxels in the storage.
Definition MACField.h:620
virtual Data_T & lvalue(int i, int j, int k)
This will return the appropriate interpolated value but setting that to something else does not chang...
Definition MACField.h:649
const_mac_comp_iterator cbegin_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition MACField.h:812
std::vector< real_t > m_w
W component storage.
Definition MACField.h:310
V3i getComponentSize() const
Returns the size of U,V,W components.
Definition MACField.h:261
void copyMAC(typename MACField::Ptr other)
TEMP: Copies the MAC field data from another MAC field. This should be re-implemented using proper it...
Definition MACField.h:250
virtual long long int memSize() const
Returns the memory usage (in bytes)
Definition MACField.h:638
static const char * staticClassName()
Definition MACField.h:115
real_t wCenter(int i, int j, int k) const
Returns the w-component interpolated to the cell center.
Definition MACField.h:243
mac_comp_iterator begin_comp(MACComponent comp)
Iterator to first element.
Definition MACField.h:868
void matchDefinition(FieldRes::Ptr fieldToMatch)
Sets up this field so that resolution and mapping matches the other.
Definition Field.h:1003
Box3i makeDataWindowForComponent(Box3i dataWindow, MACComponent comp)
Definition MACField.h:586
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition ns.h:58
Used to return a string for the name of a templated field.
Definition Traits.h:283