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* 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 
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(typename 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((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 
328 private:
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 
358 template <class Data_T>
360 {
361 public:
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 
435 private:
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 
471 template <class Data_T>
473 {
474 public:
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 
546 private:
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 
584 namespace 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 
610 template <class Data_T>
612  : base()
613 {
614 
615 }
616 
617 //----------------------------------------------------------------------------//
618 
619 template <class Data_T>
620 inline 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 
629 template <class Data_T>
630 Data_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 
637 template <class Data_T>
638 long 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 
648 template <class Data_T>
649 Data_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 
657 template <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 
696 template <class Data_T>
697 inline const typename MACField<Data_T>::real_t&
698 MACField<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 
715 template <class Data_T>
716 inline typename MACField<Data_T>::real_t&
717 MACField<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 
734 template <class Data_T>
735 inline const typename MACField<Data_T>::real_t&
736 MACField<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 
753 template <class Data_T>
754 inline typename MACField<Data_T>::real_t&
755 MACField<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 
772 template <class Data_T>
773 inline const typename MACField<Data_T>::real_t&
774 MACField<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 
791 template <class Data_T>
792 inline typename MACField<Data_T>::real_t&
793 MACField<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 
810 template <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 
824 template <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 
837 template <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 
852 template <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 
866 template <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 
879 template <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 
892 template <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 
905 template <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 
918 template <class Data_T>
919 inline const typename MACField<Data_T>::real_t*
920 MACField<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 
931 template <class Data_T>
932 inline typename MACField<Data_T>::real_t*
933 MACField<Data_T>::uPtr(int i, int j, int k)
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 
944 template <class Data_T>
945 inline const typename MACField<Data_T>::real_t*
946 MACField<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 
957 template <class Data_T>
958 inline typename MACField<Data_T>::real_t*
959 MACField<Data_T>::vPtr(int i, int j, int k)
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 
970 template <class Data_T>
971 inline const typename MACField<Data_T>::real_t*
972 MACField<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 
983 template <class Data_T>
984 inline typename MACField<Data_T>::real_t*
985 MACField<Data_T>::wPtr(int i, int j, int k)
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
MACField::const_mac_comp_iterator::real_t
MACField< Data_T >::real_t real_t
Definition: MACField.h:366
MACField::clone
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
MACField::wPtr
const real_t * wPtr(int i, int j, int k) const
Direct access to value on w-facing wall.
Definition: MACField.h:972
FIELD3D_NAMESPACE_HEADER_CLOSE
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition: ns.h:58
MACCompV
Definition: MACField.h:73
FieldBase
Definition: Field.h:91
V3i
Imath::V3i V3i
Definition: SpiMathLib.h:71
MACField::wCenter
real_t wCenter(int i, int j, int k) const
Returns the w-component interpolated to the cell center.
Definition: MACField.h:243
MACField::LinearInterp
LinearMACFieldInterp< Data_T > LinearInterp
Definition: MACField.h:107
MACField::begin_comp
mac_comp_iterator begin_comp(MACComponent comp)
Iterator to first element.
Definition: MACField.h:868
MACField::mac_comp_iterator::class_type
MACField< Data_T > class_type
Definition: MACField.h:478
MACField::const_mac_comp_iterator::x
int x
Current position.
Definition: MACField.h:433
MACField::m_wSize
V3i m_wSize
Size of W grid along each axis.
Definition: MACField.h:321
MACField::cend_comp
const_mac_comp_iterator cend_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition: MACField.h:839
operator*
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::FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
Definition: MACField.h:269
MACField::m_u
std::vector< real_t > m_u
U component storage.
Definition: MACField.h:306
MACField::CubicInterp
CubicMACFieldInterp< Data_T > CubicInterp
Definition: MACField.h:108
MACField::const_mac_comp_iterator::const_mac_comp_iterator
const_mac_comp_iterator(MACComponent comp, const class_type &field, const Box3i &window, const V3i &currentPos)
Definition: MACField.h:370
CubicMACFieldInterp
Definition: FieldInterp.h:434
MACField::v
const real_t & v(int i, int j, int k) const
Read access to value on v-facing wall.
Definition: MACField.h:736
MACField::mac_comp_iterator::m_field
class_type & m_field
Reference to field being iterated over.
Definition: MACField.h:576
MACField::mac_comp_iterator::m_p
real_t * m_p
Pointer to current element.
Definition: MACField.h:570
MACField::getComponentSize
V3i getComponentSize() const
Returns the size of U,V,W components.
Definition: MACField.h:261
MACField::const_mac_comp_iterator::class_type
MACField< Data_T > class_type
Definition: MACField.h:365
MACField::uPtr
const real_t * uPtr(int i, int j, int k) const
Direct access to value on u-facing wall.
Definition: MACField.h:920
MACField::mac_comp_iterator::m_comp
MACComponent m_comp
Component to look up.
Definition: MACField.h:574
MACField::u
const real_t & u(int i, int j, int k) const
Read access to value on u-facing wall.
Definition: MACField.h:698
MACField::const_mac_comp_iterator
Definition: MACField.h:359
MACField::staticClassType
static const char * staticClassType()
Definition: MACField.h:120
MACField::cbegin_comp
const_mac_comp_iterator cbegin_comp(MACComponent comp) const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
Definition: MACField.h:812
MACField::mac_comp_iterator::mac_comp_iterator
mac_comp_iterator(MACComponent comp, class_type &field, const Box3i &window, const V3i &currentPos)
Definition: MACField.h:483
FieldBase::name
std::string name
Optional name of the field.
Definition: Field.h:171
FieldBase::Ptr
boost::intrusive_ptr< FieldBase > Ptr
Definition: Field.h:97
MACField::const_mac_comp_iterator::updatePointer
void updatePointer()
Definition: MACField.h:439
MACField::Ptr
boost::intrusive_ptr< MACField > Ptr
Definition: MACField.h:101
MACField::m_wSizeXY
int m_wSizeXY
Size of xy slice for w component.
Definition: MACField.h:323
MACField::base
ResizableField< Data_T > base
Definition: MACField.h:336
MACField3h
MACField< V3h > MACField3h
Definition: MACField.h:350
MACField::m_w
std::vector< real_t > m_w
W component storage.
Definition: MACField.h:310
MACField3f
MACField< V3f > MACField3f
Definition: MACField.h:351
ns.h
MACField::const_mac_comp_iterator::m_field
const class_type & m_field
Reference to field being iterated over.
Definition: MACField.h:465
MACField::memSize
virtual long long int memSize() const
Returns the memory usage (in bytes)
Definition: MACField.h:638
MACCompW
Definition: MACField.h:74
detail::max
T max(const T a, const T2 b)
Max operation on mixed types.
Definition: FieldSampler.h:32
MACField::ms_classType
static TemplatedFieldType< MACField< Data_T > > ms_classType
Definition: MACField.h:332
MACField::const_mac_comp_iterator::m_window
Box3i m_window
Window to traverse.
Definition: MACField.h:461
MACField::const_mac_comp_iterator::m_p
const real_t * m_p
Pointer to current element.
Definition: MACField.h:459
MACField::mac_comp_iterator::m_window
Box3i m_window
Window to traverse.
Definition: MACField.h:572
MACField::DEFINE_FIELD_RTTI_CONCRETE_CLASS
DEFINE_FIELD_RTTI_CONCRETE_CLASS
Definition: MACField.h:113
MACField::w
const real_t & w(int i, int j, int k) const
Read access to value on w-facing wall.
Definition: MACField.h:774
MACField::value
virtual Data_T value(int i, int j, int k) const
Definition: MACField.h:630
FieldRes::dataResolution
const V3i dataResolution() const
Definition: Field.h:256
MACField::m_dummy
Data_T m_dummy
Dummy storage of a temp value that lvalue() can write to.
Definition: MACField.h:326
MACField::const_mac_comp_iterator::m_comp
MACComponent m_comp
Component to look up.
Definition: MACField.h:463
MACField::lvalue
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
MACField::clear
virtual void clear(const Data_T &value)
Clears all the voxels in the storage.
Definition: MACField.h:620
ResizableField::matchDefinition
void matchDefinition(FieldRes::Ptr fieldToMatch)
Sets up this field so that resolution and mapping matches the other.
Definition: Field.h:1003
MACField::copyMAC
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
Field.h
Contains Field, WritableField and ResizableField classes.
MACField
This subclass of Field implements a standard MAC field. Refer to your favorite fluid simulations book...
Definition: MACField.h:95
MACField::m_vSize
V3i m_vSize
Size of V grid along each axis.
Definition: MACField.h:317
MACCompU
Definition: MACField.h:72
MACField::vCenter
real_t vCenter(int i, int j, int k) const
Returns the v-component interpolated to the cell center.
Definition: MACField.h:238
MACField::m_vSizeXY
int m_vSizeXY
Size of xy slice for v component.
Definition: MACField.h:319
MACField::end_comp
mac_comp_iterator end_comp(MACComponent comp)
Iterator to first element.
Definition: MACField.h:894
MACField::m_uSizeXY
int m_uSizeXY
Size of xy slice for u component.
Definition: MACField.h:315
MACFieldUtil::makeDataWindowForComponent
Box3i makeDataWindowForComponent(Box3i dataWindow, MACComponent comp)
Definition: MACField.h:586
MACField::m_uSize
V3i m_uSize
Size of U grid along each axis.
Definition: MACField.h:313
MACComponent
MACComponent
Definition: MACField.h:71
MACField::Vec
std::vector< Ptr > Vec
Definition: MACField.h:102
MACField::const_mac_comp_iterator::z
int z
Definition: MACField.h:433
MACField::mac_comp_iterator::x
int x
Current position.
Definition: MACField.h:544
MACField::real_t
Data_T::BaseType real_t
This typedef is used to refer to the scalar component type of the vectors.
Definition: MACField.h:105
FIELD3D_NAMESPACE_OPEN
Definition: FieldMapping.cpp:74
Box3i
Imath::Box3i Box3i
Definition: SpiMathLib.h:77
MACField::class_type
MACField< Data_T > class_type
Definition: MACField.h:112
MACField::mac_comp_iterator::z
int z
Definition: MACField.h:544
MACField::mac_comp_iterator
Definition: MACField.h:472
MACField::staticClassName
static const char * staticClassName()
Definition: MACField.h:115
MACField3d
MACField< V3d > MACField3d
Definition: MACField.h:352
LinearMACFieldInterp
Definition: FieldInterp.h:312
TemplatedFieldType
Used to return a string for the name of a templated field.
Definition: Traits.h:282
MACField::sizeChanged
virtual void sizeChanged()
Subclasses should re-implement this if they need to perform memory allocations, etc....
Definition: MACField.h:658
detail::min
T min(const T a, const T2 b)
Min operation on mixed types.
Definition: FieldSampler.h:25
MACField::vPtr
const real_t * vPtr(int i, int j, int k) const
Direct access to value on v-facing wall.
Definition: MACField.h:946
MACField::MACField
MACField()
Constructs an empty buffer.
Definition: MACField.h:611
MACField::mac_comp_iterator::real_t
MACField< Data_T >::real_t real_t
Definition: MACField.h:479
MACFieldUtil
Definition: MACField.h:584
FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION
FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(MACField)
MACField::uCenter
real_t uCenter(int i, int j, int k) const
Returns the u-component interpolated to the cell center.
Definition: MACField.h:233
ResizableField
Definition: Field.h:833
MACField::m_v
std::vector< real_t > m_v
V component storage.
Definition: MACField.h:308
MACField::mac_comp_iterator::updatePointer
void updatePointer()
Definition: MACField.h:550