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 
62 template <class T>
64 template <class T>
65 class CubicMACFieldInterp;
66 
67 //----------------------------------------------------------------------------//
68 // Enumerators
69 //----------------------------------------------------------------------------//
70 
72  MACCompU = 0,
75 };
76 
77 //----------------------------------------------------------------------------//
78 // MACField
79 //----------------------------------------------------------------------------//
80 
92 //----------------------------------------------------------------------------//
93 
94 template <class Data_T>
95 class MACField : public ResizableField<Data_T>
96 {
97 public:
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* classType()
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 
198 
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 
250  void copyMAC(MACField::Ptr other)
251  {
252  matchDefinition(other);
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(m_u.size(), m_v.size(), m_w.size()); }
263 
264  // From FieldBase ------------------------------------------------------------
265 
268 
269  virtual std::string className() const
270  { return staticClassName(); }
271 
272  virtual FieldBase::Ptr clone() const
273  { return Ptr(new MACField(*this)); }
274 
276 
277  protected:
278 
279  // From ResizableField class ---------------------------------------------
280 
281  virtual void sizeChanged();
282 
283  // Concrete component access -------------------------------------------------
284 
287  const real_t* uPtr(int i, int j, int k) const;
290  real_t* uPtr(int i, int j, int k);
293  const real_t* vPtr(int i, int j, int k) const;
296  real_t* vPtr(int i, int j, int k);
299  const real_t* wPtr(int i, int j, int k) const;
302  real_t* wPtr(int i, int j, int k);
303 
304  // Data members --------------------------------------------------------------
305 
307  std::vector<real_t> m_u;
309  std::vector<real_t> m_v;
311  std::vector<real_t> m_w;
312 
325 
327  mutable Data_T m_dummy;
328 
329 private:
330 
331  // Static data members -------------------------------------------------------
332 
334 
335  // Typedefs ------------------------------------------------------------------
336 
338 
339 };
340 
341 //----------------------------------------------------------------------------//
342 // Static member instantiation
343 //----------------------------------------------------------------------------//
344 
346 
347 //----------------------------------------------------------------------------//
348 // Typedefs
349 //----------------------------------------------------------------------------//
350 
354 
355 //----------------------------------------------------------------------------//
356 // MACField::const_mac_comp_iterator
357 //----------------------------------------------------------------------------//
358 
359 template <class Data_T>
361 {
362 public:
363 
364  // Typedefs ------------------------------------------------------------------
365 
368 
369  // Constructors --------------------------------------------------------------
370 
372  const class_type &field,
373  const Box3i &window,
374  const V3i &currentPos)
375  : x(currentPos.x), y(currentPos.y), z(currentPos.z),
376  m_p(NULL), m_window(window), m_comp(comp),
377  m_field(field)
378  {
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  x = m_window.min.x;
389  y = m_window.min.y;
390  ++z;
391  } else {
392  x = m_window.min.x;
393  ++y;
394  }
395  updatePointer();
396  } else {
397  ++x;
398  ++m_p;
399  }
400  return *this;
401  }
402 
403  template <class Iter_T>
404  inline bool operator == (const Iter_T &rhs) const
405  {
406  return m_p == &(*rhs);
407  }
408 
409  template <class Iter_T>
410  inline bool operator != (const Iter_T &rhs) const
411  {
412  return m_p != &(*rhs);
413  }
414 
415  inline const real_t& operator * () const
416  {
417  return *m_p;
418  }
419 
420  inline const real_t* operator -> () const
421  {
422  return m_p;
423  }
424 
425  // Public data members -------------------------------------------------------
426 
428  int x, y, z;
429 
430 private:
431 
432  // Convenience methods -------------------------------------------------------
433 
435  {
436  switch (m_comp) {
437  case MACCompU:
438  m_p = m_field.uPtr(x, y, z);
439  break;
440  case MACCompV:
441  m_p = m_field.vPtr(x, y, z);
442  break;
443  case MACCompW:
444  m_p = m_field.wPtr(x, y, z);
445  break;
446  default:
447  assert(false && "Illegal MACComponent in const_mac_comp_iterator");
448  }
449  }
450 
451  // Private data members ------------------------------------------------------
452 
454  const real_t *m_p;
461 
462 };
463 
464 //----------------------------------------------------------------------------//
465 
466 template <class Data_T>
468 {
469 public:
470 
471  // Typedefs ------------------------------------------------------------------
472 
475 
476  // Constructors --------------------------------------------------------------
477 
479  const Box3i &window, const V3i &currentPos)
480  : x(currentPos.x), y(currentPos.y), z(currentPos.z),
481  m_p(NULL), m_window(window), m_comp(comp),
482  m_field(field)
483  {
484  updatePointer();
485  }
486 
487  // Operators -----------------------------------------------------------------
488 
489  mac_comp_iterator& operator ++ ()
490  {
491  if (x == m_window.max.x) {
492  if (y == m_window.max.y) {
493  x = m_window.min.x;
494  y = m_window.min.y;
495  ++z;
496  } else {
497  x = m_window.min.x;
498  ++y;
499  }
500  updatePointer();
501  } else {
502  ++x;
503  ++m_p;
504  }
505  return *this;
506  }
507 
508  template <class Iter_T>
509  inline bool operator == (const Iter_T &rhs) const
510  {
511  return m_p == &(*rhs);
512  }
513 
514  template <class Iter_T>
515  inline bool operator != (const Iter_T &rhs) const
516  {
517  return m_p != &(*rhs);
518  }
519 
520  inline real_t& operator * () const
521  {
522  return *m_p;
523  }
524 
525  inline real_t* operator -> () const
526  {
527  return m_p;
528  }
529 
530  // Public data members -------------------------------------------------------
531 
533  int x, y, z;
534 
535 private:
536 
537  // Convenience methods -------------------------------------------------------
538 
540  {
541  switch (m_comp) {
542  case MACCompU:
543  m_p = m_field.uPtr(x, y, z);
544  break;
545  case MACCompV:
546  m_p = m_field.vPtr(x, y, z);
547  break;
548  case MACCompW:
549  m_p = m_field.wPtr(x, y, z);
550  break;
551  default:
552  assert(false && "Illegal MACComponent in const_mac_comp_iterator");
553  }
554  }
555 
556  // Private data members ------------------------------------------------------
557 
566 
567 };
568 
569 //----------------------------------------------------------------------------//
570 // Implementation specific helpers
571 //----------------------------------------------------------------------------//
572 
573 namespace MACFieldUtil {
574 
576  {
577  switch (comp) {
578  case MACCompU:
579  dataWindow.max += V3i(1, 0, 0);
580  break;
581  case MACCompV:
582  dataWindow.max += V3i(0, 1, 0);
583  break;
584  case MACCompW:
585  dataWindow.max += V3i(0, 0, 1);
586  break;
587  default:
588  assert(false && "Illegal MACComponent in makeDataWindowForComponent");
589  }
590  return dataWindow;
591  }
592 
593 }
594 
595 //----------------------------------------------------------------------------//
596 // MACField implementations
597 //----------------------------------------------------------------------------//
598 
599 template <class Data_T>
601  : base()
602 {
603 
604 }
605 
606 //----------------------------------------------------------------------------//
607 
608 template <class Data_T>
609 inline void MACField<Data_T>::clear(const Data_T &value)
610 {
611  std::fill(m_u.begin(), m_u.end(), value.x);
612  std::fill(m_v.begin(), m_v.end(), value.y);
613  std::fill(m_w.begin(), m_w.end(), value.z);
614 }
615 
616 //----------------------------------------------------------------------------//
617 
618 template <class Data_T>
619 Data_T MACField<Data_T>::value(int i, int j, int k) const
620 {
621  return Data_T(uCenter(i, j, k), vCenter(i, j, k), wCenter(i, j, k));
622 }
623 
624 //----------------------------------------------------------------------------//
625 
626 template <class Data_T>
627 long long int MACField<Data_T>::memSize() const
628 {
629  long long int superClassMemSize = base::memSize();
630  long long int vectorMemSize =
631  (m_u.capacity() + m_v.capacity() + m_w.capacity()) * sizeof(real_t);
632  return sizeof(*this) + vectorMemSize + superClassMemSize;
633 }
634 
635 //----------------------------------------------------------------------------//
636 
637 template <class Data_T>
638 Data_T& MACField<Data_T>::lvalue(int i, int j, int k)
639 {
640  m_dummy = value(i, j, k);
641  return m_dummy;
642 }
643 
644 //----------------------------------------------------------------------------//
645 
646 template <class Data_T>
648 {
649  // Call base class
650  base::sizeChanged();
651 
652  V3i baseSize =
653  base::m_dataWindow.max - base::m_dataWindow.min + V3i(1);
654 
655  if (std::min(std::min(baseSize.x, baseSize.y), baseSize.z) < 0)
656  throw Exc::ResizeException("Attempt to resize ResizableField object "
657  "using negative size. Data window was: " +
658  boost::lexical_cast<std::string>(baseSize));
659 
660  // Calculate the size for each component of the MAC field
661  m_uSize = baseSize + V3i(1, 0, 0);
662  m_vSize = baseSize + V3i(0, 1, 0);
663  m_wSize = baseSize + V3i(0, 0, 1);
664 
665  // Calculate the size of each z slice
666  m_uSizeXY = m_uSize.x * m_uSize.y;
667  m_vSizeXY = m_vSize.x * m_vSize.y;
668  m_wSizeXY = m_wSize.x * m_wSize.y;
669 
670  // Allocate memory
671  try {
672  m_u.resize(m_uSize.x * m_uSize.y * m_uSize.z);
673  m_v.resize(m_vSize.x * m_vSize.y * m_vSize.z);
674  m_w.resize(m_wSize.x * m_wSize.y * m_wSize.z);
675  }
676  catch (std::bad_alloc &e) {
677  throw Exc::MemoryException("Couldn't allocate MACField of size " +
678  boost::lexical_cast<std::string>(baseSize));
679  }
680 
681 }
682 
683 //----------------------------------------------------------------------------//
684 
685 template <class Data_T>
686 inline const typename MACField<Data_T>::real_t&
687 MACField<Data_T>::u(int i, int j, int k) const
688 {
689  assert (i >= base::m_dataWindow.min.x);
690  assert (i <= base::m_dataWindow.max.x + 1);
691  assert (j >= base::m_dataWindow.min.y);
692  assert (j <= base::m_dataWindow.max.y);
693  assert (k >= base::m_dataWindow.min.z);
694  assert (k <= base::m_dataWindow.max.z);
695  // Add crop window offset
696  i -= base::m_dataWindow.min.x;
697  j -= base::m_dataWindow.min.y;
698  k -= base::m_dataWindow.min.z;
699  return m_u[i + j * m_uSize.x + k * m_uSizeXY];
700 }
701 
702 //----------------------------------------------------------------------------//
703 
704 template <class Data_T>
705 inline typename MACField<Data_T>::real_t&
706 MACField<Data_T>::u(int i, int j, int k)
707 {
708  assert (i >= base::m_dataWindow.min.x);
709  assert (i <= base::m_dataWindow.max.x + 1);
710  assert (j >= base::m_dataWindow.min.y);
711  assert (j <= base::m_dataWindow.max.y);
712  assert (k >= base::m_dataWindow.min.z);
713  assert (k <= base::m_dataWindow.max.z);
714  // Add crop window offset
715  i -= base::m_dataWindow.min.x;
716  j -= base::m_dataWindow.min.y;
717  k -= base::m_dataWindow.min.z;
718  return m_u[i + j * m_uSize.x + k * m_uSizeXY];
719 }
720 
721 //----------------------------------------------------------------------------//
722 
723 template <class Data_T>
724 inline const typename MACField<Data_T>::real_t&
725 MACField<Data_T>::v(int i, int j, int k) const
726 {
727  assert (i >= base::m_dataWindow.min.x);
728  assert (i <= base::m_dataWindow.max.x);
729  assert (j >= base::m_dataWindow.min.y);
730  assert (j <= base::m_dataWindow.max.y + 1);
731  assert (k >= base::m_dataWindow.min.z);
732  assert (k <= base::m_dataWindow.max.z);
733  // Add crop window offset
734  i -= base::m_dataWindow.min.x;
735  j -= base::m_dataWindow.min.y;
736  k -= base::m_dataWindow.min.z;
737  return m_v[i + j * m_vSize.x + k * m_vSizeXY];
738 }
739 
740 //----------------------------------------------------------------------------//
741 
742 template <class Data_T>
743 inline typename MACField<Data_T>::real_t&
744 MACField<Data_T>::v(int i, int j, int k)
745 {
746  assert (i >= base::m_dataWindow.min.x);
747  assert (i <= base::m_dataWindow.max.x);
748  assert (j >= base::m_dataWindow.min.y);
749  assert (j <= base::m_dataWindow.max.y + 1);
750  assert (k >= base::m_dataWindow.min.z);
751  assert (k <= base::m_dataWindow.max.z);
752  // Add crop window offset
753  i -= base::m_dataWindow.min.x;
754  j -= base::m_dataWindow.min.y;
755  k -= base::m_dataWindow.min.z;
756  return m_v[i + j * m_vSize.x + k * m_vSizeXY];
757 }
758 
759 //----------------------------------------------------------------------------//
760 
761 template <class Data_T>
762 inline const typename MACField<Data_T>::real_t&
763 MACField<Data_T>::w(int i, int j, int k) const
764 {
765  assert (i >= base::m_dataWindow.min.x);
766  assert (i <= base::m_dataWindow.max.x);
767  assert (j >= base::m_dataWindow.min.y);
768  assert (j <= base::m_dataWindow.max.y);
769  assert (k >= base::m_dataWindow.min.z);
770  assert (k <= base::m_dataWindow.max.z + 1);
771  // Add crop window offset
772  i -= base::m_dataWindow.min.x;
773  j -= base::m_dataWindow.min.y;
774  k -= base::m_dataWindow.min.z;
775  return m_w[i + j * m_wSize.x + k * m_wSizeXY];
776 }
777 
778 //----------------------------------------------------------------------------//
779 
780 template <class Data_T>
781 inline typename MACField<Data_T>::real_t&
782 MACField<Data_T>::w(int i, int j, int k)
783 {
784  assert (i >= base::m_dataWindow.min.x);
785  assert (i <= base::m_dataWindow.max.x);
786  assert (j >= base::m_dataWindow.min.y);
787  assert (j <= base::m_dataWindow.max.y);
788  assert (k >= base::m_dataWindow.min.z);
789  assert (k <= base::m_dataWindow.max.z + 1);
790  // Add crop window offset
791  i -= base::m_dataWindow.min.x;
792  j -= base::m_dataWindow.min.y;
793  k -= base::m_dataWindow.min.z;
794  return m_w[i + j * m_wSize.x + k * m_wSizeXY];
795 }
796 
797 //----------------------------------------------------------------------------//
798 
799 template <class Data_T>
802 {
803  using namespace MACFieldUtil;
804  if (FieldRes::dataResolution() == V3i(0))
805  return cend_comp(comp);
806  Box3i dataWindow =
807  makeDataWindowForComponent(base::m_dataWindow, comp);
808  return const_mac_comp_iterator(comp, *this, dataWindow, dataWindow.min);
809 }
810 
811 //----------------------------------------------------------------------------//
812 
813 template <class Data_T>
816 {
817  using namespace MACFieldUtil;
818  if (subset.isEmpty())
819  return cend_comp(comp, subset);
820  Box3i dataWindow = makeDataWindowForComponent(subset, comp);
821  return const_mac_comp_iterator(comp, *this, dataWindow, subset.min);
822 }
823 
824 //----------------------------------------------------------------------------//
825 
826 template <class Data_T>
829 {
830  using namespace MACFieldUtil;
831  Box3i dataWindow =
832  makeDataWindowForComponent(base::m_dataWindow, comp);
833  return const_mac_comp_iterator(comp, *this, dataWindow,
834  V3i(dataWindow.min.x,
835  dataWindow.min.y,
836  dataWindow.max.z + 1));
837 }
838 
839 //----------------------------------------------------------------------------//
840 
841 template <class Data_T>
844 {
845  using namespace MACFieldUtil;
846  Box3i dataWindow = makeDataWindowForComponent(subset, comp);
847  return const_mac_comp_iterator(comp, *this, dataWindow,
848  V3i(dataWindow.min.x,
849  dataWindow.min.y,
850  dataWindow.max.z + 1));
851 }
852 
853 //----------------------------------------------------------------------------//
854 
855 template <class Data_T>
858 {
859  using namespace MACFieldUtil;
860  if (FieldRes::dataResolution() == V3i(0))
861  return end_comp(comp);
862  Box3i dataWindow = makeDataWindowForComponent(base::m_dataWindow, comp);
863  return mac_comp_iterator(comp, *this, dataWindow, dataWindow.min);
864 }
865 
866 //----------------------------------------------------------------------------//
867 
868 template <class Data_T>
871 {
872  using namespace MACFieldUtil;
873  if (subset.isEmpty())
874  return end_comp(comp, subset);
875  Box3i dataWindow = makeDataWindowForComponent(subset, comp);
876  return mac_comp_iterator(comp, *this, dataWindow, subset.min);
877 }
878 
879 //----------------------------------------------------------------------------//
880 
881 template <class Data_T>
884 {
885  using namespace MACFieldUtil;
886  Box3i dataWindow = makeDataWindowForComponent(base::m_dataWindow, comp);
887  return mac_comp_iterator(comp, *this, dataWindow, V3i(dataWindow.min.x,
888  dataWindow.min.y,
889  dataWindow.max.z + 1));
890 }
891 
892 //----------------------------------------------------------------------------//
893 
894 template <class Data_T>
897 {
898  using namespace MACFieldUtil;
899  Box3i dataWindow = makeDataWindowForComponent(subset, comp);
900  return mac_comp_iterator(comp, *this, dataWindow, V3i(dataWindow.min.x,
901  dataWindow.min.y,
902  dataWindow.max.z + 1));
903 }
904 
905 //----------------------------------------------------------------------------//
906 
907 template <class Data_T>
908 inline const typename MACField<Data_T>::real_t*
909 MACField<Data_T>::uPtr(int i, int j, int k) const
910 {
911  // Add crop window offset
912  i -= base::m_dataWindow.min.x;
913  j -= base::m_dataWindow.min.y;
914  k -= base::m_dataWindow.min.z;
915  return &m_u[i + j * m_uSize.x + k * m_uSizeXY];
916 }
917 
918 //----------------------------------------------------------------------------//
919 
920 template <class Data_T>
921 inline typename MACField<Data_T>::real_t*
922 MACField<Data_T>::uPtr(int i, int j, int k)
923 {
924  // Add crop window offset
925  i -= base::m_dataWindow.min.x;
926  j -= base::m_dataWindow.min.y;
927  k -= base::m_dataWindow.min.z;
928  return &m_u[i + j * m_uSize.x + k * m_uSizeXY];
929 }
930 
931 //----------------------------------------------------------------------------//
932 
933 template <class Data_T>
934 inline const typename MACField<Data_T>::real_t*
935 MACField<Data_T>::vPtr(int i, int j, int k) const
936 {
937  // Add crop window offset
938  i -= base::m_dataWindow.min.x;
939  j -= base::m_dataWindow.min.y;
940  k -= base::m_dataWindow.min.z;
941  return &m_v[i + j * m_vSize.x + k * m_vSizeXY];
942 }
943 
944 //----------------------------------------------------------------------------//
945 
946 template <class Data_T>
947 inline typename MACField<Data_T>::real_t*
948 MACField<Data_T>::vPtr(int i, int j, int k)
949 {
950  // Add crop window offset
951  i -= base::m_dataWindow.min.x;
952  j -= base::m_dataWindow.min.y;
953  k -= base::m_dataWindow.min.z;
954  return &m_v[i + j * m_vSize.x + k * m_vSizeXY];
955 }
956 
957 //----------------------------------------------------------------------------//
958 
959 template <class Data_T>
960 inline const typename MACField<Data_T>::real_t*
961 MACField<Data_T>::wPtr(int i, int j, int k) const
962 {
963  // Add crop window offset
964  i -= base::m_dataWindow.min.x;
965  j -= base::m_dataWindow.min.y;
966  k -= base::m_dataWindow.min.z;
967  return &m_w[i + j * m_wSize.x + k * m_wSizeXY];
968 }
969 
970 //----------------------------------------------------------------------------//
971 
972 template <class Data_T>
973 inline typename MACField<Data_T>::real_t*
974 MACField<Data_T>::wPtr(int i, int j, int k)
975 {
976  // Add crop window offset
977  i -= base::m_dataWindow.min.x;
978  j -= base::m_dataWindow.min.y;
979  k -= base::m_dataWindow.min.z;
980  return &m_w[i + j * m_wSize.x + k * m_wSizeXY];
981 }
982 
983 //----------------------------------------------------------------------------//
984 
986 
987 //----------------------------------------------------------------------------//
988 
989 #endif // Include guard
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition: ns.h:58
Imath::Box3i Box3i
Definition: SpiMathLib.h:77
real_t wCenter(int i, int j, int k) const
Returns the w-component interpolated to the cell center.
Definition: MACField.h:243
MACField< Data_T >::real_t real_t
Definition: MACField.h:367
const real_t * m_p
Pointer to current element.
Definition: MACField.h:454
const class_type & m_field
Reference to field being iterated over.
Definition: MACField.h:460
mac_comp_iterator(MACComponent comp, class_type &field, const Box3i &window, const V3i &currentPos)
Definition: MACField.h:478
std::vector< real_t > m_v
V component storage.
Definition: MACField.h:309
mac_comp_iterator begin_comp(MACComponent comp)
Iterator to first element.
Definition: MACField.h:857
MACComponent m_comp
Component to look up.
Definition: MACField.h:458
V3i getComponentSize() const
Returns the size of U,V,W components.
Definition: MACField.h:261
int x
Current position.
Definition: MACField.h:428
This subclass of Field implements a standard MAC field. Refer to your favorite fluid simulations book...
Definition: MACField.h:95
Box3i makeDataWindowForComponent(Box3i dataWindow, MACComponent comp)
Definition: MACField.h:575
ResizableField< Data_T > base
Definition: MACField.h:337
void matchDefinition(FieldRes::Ptr fieldToMatch)
Sets up this field so that resolution and mapping matches the other.
Definition: Field.h:961
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:272
const real_t & v(int i, int j, int k) const
Read access to value on v-facing wall.
Definition: MACField.h:725
std::vector< real_t > m_w
W component storage.
Definition: MACField.h:311
CubicMACFieldInterp< Data_T > CubicInterp
Definition: MACField.h:108
const real_t & u(int i, int j, int k) const
Read access to value on u-facing wall.
Definition: MACField.h:687
boost::intrusive_ptr< FieldBase > Ptr
Definition: Field.h:97
real_t uCenter(int i, int j, int k) const
Returns the u-component interpolated to the cell center.
Definition: MACField.h:233
FIELD3D_VEC3_T< T > operator*(S s, const FIELD3D_VEC3_T< T > vec)
Scalar times Vec3 multiplication. Makes the interpolation calls cleaner.
Definition: FieldInterp.h:1558
MACField< Data_T > class_type
Definition: MACField.h:366
MACComponent
Definition: MACField.h:71
real_t * m_p
Pointer to current element.
Definition: MACField.h:559
virtual long long int memSize() const
Returns the memory usage (in bytes)
Definition: MACField.h:627
const real_t * wPtr(int i, int j, int k) const
Direct access to value on w-facing wall.
Definition: MACField.h:961
class_type & m_field
Reference to field being iterated over.
Definition: MACField.h:565
virtual Data_T value(int i, int j, int k) const
Definition: MACField.h:619
Imath::V3i V3i
Definition: SpiMathLib.h:71
MACField< V3d > MACField3d
Definition: MACField.h:353
int m_wSizeXY
Size of xy slice for w component.
Definition: MACField.h:324
const real_t & w(int i, int j, int k) const
Read access to value on w-facing wall.
Definition: MACField.h:763
DEFINE_FIELD_RTTI_CONCRETE_CLASS
Definition: MACField.h:113
boost::intrusive_ptr< MACField > Ptr
Definition: MACField.h:101
FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(MACField)
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:638
static TemplatedFieldType< MACField< Data_T > > ms_classType
Definition: MACField.h:333
MACComponent m_comp
Component to look up.
Definition: MACField.h:563
int m_vSizeXY
Size of xy slice for v component.
Definition: MACField.h:320
const real_t * uPtr(int i, int j, int k) const
Direct access to value on u-facing wall.
Definition: MACField.h:909
MACField< V3h > MACField3h
Definition: MACField.h:351
mac_comp_iterator end_comp(MACComponent comp)
Iterator to first element.
Definition: MACField.h:883
V3i m_uSize
Size of U grid along each axis.
Definition: MACField.h:314
const_mac_comp_iterator(MACComponent comp, const class_type &field, const Box3i &window, const V3i &currentPos)
Definition: MACField.h:371
static const char * classType()
Definition: MACField.h:120
real_t vCenter(int i, int j, int k) const
Returns the v-component interpolated to the cell center.
Definition: MACField.h:238
Used to return a string for the name of a templated field.
Definition: Traits.h:116
V3i const dataResolution() const
Definition: Field.h:258
Data_T m_dummy
Dummy storage of a temp value that lvalue() can write to.
Definition: MACField.h:327
Data_T::BaseType real_t
This typedef is used to refer to the scalar component type of the vectors.
Definition: MACField.h:105
Contains Field, WritableField and ResizableField classes.
int m_uSizeXY
Size of xy slice for u component.
Definition: MACField.h:316
virtual void clear(const Data_T &value)
Clears all the voxels in the storage.
Definition: MACField.h:609
const_mac_comp_iterator cend_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition: MACField.h:828
const real_t * vPtr(int i, int j, int k) const
Direct access to value on v-facing wall.
Definition: MACField.h:935
V3i m_vSize
Size of V grid along each axis.
Definition: MACField.h:318
Box3i m_window
Window to traverse.
Definition: MACField.h:561
int x
Current position.
Definition: MACField.h:533
const_mac_comp_iterator cbegin_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition: MACField.h:801
virtual void sizeChanged()
Subclasses should re-implement this if they need to perform memory allocations, etc. every time the size of the storage changes.
Definition: MACField.h:647
MACField< Data_T >::real_t real_t
Definition: MACField.h:474
std::vector< Ptr > Vec
Definition: MACField.h:102
MACField()
Constructs an empty buffer.
Definition: MACField.h:600
Box3i m_window
Window to traverse.
Definition: MACField.h:456
MACField< Data_T > class_type
Definition: MACField.h:112
LinearMACFieldInterp< Data_T > LinearInterp
Definition: MACField.h:107
virtual std::string className() const
Returns the class name of the object. Used by the class pool and when writing the data to disk...
Definition: MACField.h:269
MACField< Data_T > class_type
Definition: MACField.h:473
static const char * staticClassName()
Definition: MACField.h:115
void copyMAC(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
V3i m_wSize
Size of W grid along each axis.
Definition: MACField.h:322
MACField< V3f > MACField3f
Definition: MACField.h:352
std::vector< real_t > m_u
U component storage.
Definition: MACField.h:307
std::string name
Optional name of the field.
Definition: Field.h:173
#define FIELD3D_NAMESPACE_OPEN
Definition: ns.h:56