45#ifndef _INCLUDED_Field3D_Field_H_
46#define _INCLUDED_Field3D_Field_H_
52#include <boost/intrusive_ptr.hpp>
53#include <boost/thread/mutex.hpp>
97 typedef boost::intrusive_ptr<FieldBase>
Ptr;
125 return staticClassName();
156 {
return m_metadata; }
160 {
return m_metadata; }
213 typedef boost::intrusive_ptr<FieldRes>
Ptr;
214 typedef std::vector<Ptr>
Vec;
222 {
return std::string(
"FieldRes"); }
280 {
return sizeof(*this); }
292 return res.x * res.y * res.z;
354 "Tried to call FieldRes::setMapping with null pointer");
388template <
class Data_T>
395 typedef boost::intrusive_ptr<Field>
Ptr;
403 typedef std::vector<Ptr>
Vec;
430 class const_iterator;
450 virtual Data_T
value(
int i,
int j,
int k)
const = 0;
473#define FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION \
474 virtual std::string className() const \
475 { return staticClassName(); } \
476 virtual std::string classType() const \
477 { return staticClassType(); } \
479#define FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(field) \
480 template <typename Data_T> \
481 TemplatedFieldType<field<Data_T> > field<Data_T>::ms_classType = \
482 TemplatedFieldType<field<Data_T> >(); \
490template <
class Data_T>
495#if defined(WIN32) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
496 typedef std::forward_iterator_tag iterator_category;
498 typedef ptrdiff_t difference_type;
499 typedef ptrdiff_t distance_type;
500 typedef Data_T *pointer;
501 typedef Data_T& reference;
507 : x(i.x), y(i.y), z(i.z),
508 m_window(i.m_window), m_field(i.m_field)
512 const V3i ¤tPos)
513 : x(currentPos.x), y(currentPos.y), z(currentPos.z),
514 m_window(window), m_field(field)
521 if (x == m_window.max.x) {
522 if (y == m_window.max.y) {
535 template <
class Iter_T>
536 bool operator == (
const Iter_T &rhs)
const
538 return x == rhs.
x && y == rhs.y && z == rhs.z;
540 template <
class Iter_T>
541 bool operator != (
const Iter_T &rhs)
const
543 return x != rhs.x || y != rhs.y || z != rhs.z;
547 return m_field.value(x, y, z);
567template <
class Data_T>
578template <
class Data_T>
582 if (subset.isEmpty())
589template <
class Data_T>
594 V3i(m_dataWindow.min.x,
596 m_dataWindow.max.z + 1));
601template <
class Data_T>
622template <
class Data_T>
624 :
public Field<Data_T>
630 typedef boost::intrusive_ptr<WritableField>
Ptr;
639 return "WritableField";
654 inline iterator
begin();
658 inline iterator
end();
661 inline iterator
end(
const Box3i &subset);
673 virtual Data_T&
lvalue(
int i,
int j,
int k) = 0;
702template <
class Data_T>
706#if defined(WIN32) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
707 typedef std::forward_iterator_tag iterator_category;
709 typedef ptrdiff_t difference_type;
710 typedef ptrdiff_t distance_type;
711 typedef Data_T *pointer;
712 typedef Data_T& reference;
718 const V3i ¤tPos)
719 : x(currentPos.x), y(currentPos.y), z(currentPos.z),
720 m_window(window), m_field(field)
727 if (x == m_window.max.x) {
728 if (y == m_window.max.y) {
742 template <
class Iter_T>
743 bool operator == (
const Iter_T &rhs)
const
745 return x == rhs.
x && y == rhs.y && z == rhs.z;
748 template <
class Iter_T>
749 bool operator != (
const Iter_T &rhs)
const
751 return x != rhs.x || y != rhs.y || z != rhs.z;
756 return m_field.lvalue(x, y, z);
777template <
class Data_T>
789template <
class Data_T>
793 if (subset.isEmpty())
795 return iterator(*
this, subset, subset.min);
800template <
class Data_T>
811template <
class Data_T>
815 V3i(subset.min.x, subset.min.y, subset.max.z + 1));
832template <
class Data_T>
840 typedef boost::intrusive_ptr<ResizableField>
Ptr;
849 return "ResizableField";
880 template <
class Data_T2>
912template <
class Data_T>
929template <
class Data_T>
940template <
class Data_T>
942 const Box3i &dataWindow)
952template <
class Data_T>
958 assert(padding >= 0);
966template <
class Data_T>
978 for (; i != end; ++i, ++c)
984template <
class Data_T>
985template <
class Data_T2>
996 for (; i != end; ++i, ++c)
1002template <
class Data_T>
1005 setSize(fieldToMatch->extents(), fieldToMatch->dataWindow());
1015template <
class Data_T,
class Data_T2>
1018 double tolerance = 0.0)
1036template <
class Data_T>
1048 for (; is1 != ie1; ++is1, ++is2) {
1063 return static_cast<int>(std::floor(contCoord));
1072 return static_cast<double>(discCoord) + 0.5;
1114 result.min.x =
static_cast<float>(bbox.min.x);
1115 result.min.y =
static_cast<float>(bbox.min.y);
1116 result.min.z =
static_cast<float>(bbox.min.z);
1117 result.max.x =
static_cast<float>(bbox.max.x + 1);
1118 result.max.y =
static_cast<float>(bbox.max.y + 1);
1119 result.max.z =
static_cast<float>(bbox.max.z + 1);
1148 result.min.x = std::max(bbox.min.x, bounds.min.x);
1149 result.min.y = std::max(bbox.min.y, bounds.min.y);
1150 result.min.z = std::max(bbox.min.z, bounds.min.z);
1151 result.max.x = std::min(bbox.max.x, bounds.max.x);
1152 result.max.y = std::min(bbox.max.y, bounds.max.y);
1153 result.max.z = std::min(bbox.max.z, bounds.max.z);
1160template <
class Iter_T>
1166 for (
int i=0; i<num; ++i, ++iter) {
1174template <
class Iter_T>
1175void advance(Iter_T &iter,
int num,
const Iter_T &end)
1180 for (
int i=0; i<num && iter != end; ++i, ++iter) {
1189 const int i = idx % res.x;
1190 const int j = (idx / res.x) % res.y;
1191 const int k = idx / (res.x * res.y);
1192 return V3i(i, j, k);
Contains Exception base class.
#define DECLARE_FIELD3D_GENERIC_EXCEPTION(name, base_class)
Used to declare a generic but named exception.
FIELD3D_VEC3_T< T > operator*(S s, const FIELD3D_VEC3_T< T > vec)
Scalar times Vec3 multiplication. Makes the interpolation calls cleaner.
Contains the FieldMapping base class and the NullFieldMapping and MatrixFieldMapping subclasses.
Box3d continuousBounds(const Box3i &bbox)
int contToDisc(double contCoord)
Goes from continuous coordinates to discrete coordinates See Graphics Gems - What is a pixel.
Box3i discreteBounds(const Box3d &bbox)
Converts a floating point bounding box to an integer bounding box.
Box3i clipBounds(const Box3i &bbox, const Box3i &bounds)
bool sameDefinition(typename Field< Data_T >::Ptr a, typename Field< Data_T2 >::Ptr b, double tolerance=0.0)
Checks whether the mapping and resolution in two different fields are identical.
#define FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(field)
double discToCont(int discCoord)
Goes from discrete coordinates to continuous coordinates See Graphics Gems - What is a pixel.
bool isIdentical(typename Field< Data_T >::Ptr a, typename Field< Data_T >::Ptr b)
Checks whether the span and data in two different fields are identical.
V3i indexToCoord(const size_t idx, const V3i &res)
Contains the Log class which can be used to redirect output to an arbitrary destination.
Contains base class for reference counting with Mutex.
Contains typedefs for the commonly used types in Field3D.
To_T clampForType(const From_T v)
virtual Ptr clone() const =0
Returns a pointer to a copy of the field, pure virtual so ensure derived classes properly implement i...
virtual std::string className() const =0
Returns the class name of the object. Used by the class pool and when writing the data to disk.
const FieldMetadata & metadata() const
Read only access to the m_metadata class.
boost::intrusive_ptr< FieldBase > Ptr
FieldMetadata & metadata()
accessor to the m_metadata class
static const char * staticClassName()
static const char * staticClassType()
std::string attribute
Optional name of the attribute the field represents.
void copyMetadata(const FieldBase &field)
Copies the metadata from a second field.
virtual std::string classType() const =0
Returns the full class type string.
FieldMetadata m_metadata
metadata
std::string name
Optional name of the field.
boost::intrusive_ptr< FieldMapping > Ptr
Box3i m_extents
Defines the extents of the the storage. This may be larger or smaller than the data window,...
boost::intrusive_ptr< FieldRes > Ptr
static const char * staticClassType()
V3i const dataResolution() const
virtual std::string dataTypeString() const
void setMapping(FieldMapping::Ptr mapping)
Sets the field's mapping.
virtual size_t voxelCount() const
Counts the number of voxels. For most fields, this is just the volume of the data window,...
FieldMapping::Ptr mapping()
Returns a pointer to the mapping.
Box3i m_dataWindow
Defines the area where data is allocated. This should be treated as a closed (i.e....
DEFINE_FIELD_RTTI_ABSTRACT_CLASS
virtual long long int memSize() const
Returns the memory usage (in bytes)
const FieldMapping::Ptr mapping() const
Returns a pointer to the mapping.
FieldMapping::Ptr m_mapping
Pointer to the field's mapping.
FieldRes()
This constructor ensures that we have a valid mapping at all times.
FieldBase base
Convenience typedef for referring to base class.
const Box3i & extents() const
Returns the extents of the data. This signifies the relevant area that the data exists over....
const Box3i & dataWindow() const
Returns the data window. Any coordinate inside this window is safe to pass to value() in the Field su...
bool isInBounds(int i, int j, int k) const
Returns true is the indicies are in bounds of the data window.
MatrixFieldMapping default_mapping
virtual void mappingChanged()
Tells the subclass that the mapping changed.
static const char * staticClassName()
const Field< Data_T > & m_field
Reference to field being iterated over.
Box3i m_window
Window to traverse.
const_iterator(const const_iterator &i)
const_iterator(const Field< Data_T > &field, const Box3i &window, const V3i ¤tPos)
static TemplatedFieldType< Field< Data_T > > ms_classType
DEFINE_FIELD_RTTI_ABSTRACT_CLASS
boost::intrusive_ptr< Field > Ptr
virtual std::string dataTypeString() const
static const char * staticClassType()
virtual Data_T value(int i, int j, int k) const =0
Read access to a voxel. The coordinates are in integer voxel space .
const_iterator cend(const Box3i &subset) const
Const iterator pointing one element past the last valid one (for a subset)
Field< Data_T > class_type
const_iterator cbegin(const Box3i &subset) const
Const iterator to first element of specific subset.
const_iterator cend() const
Const iterator pointing one element past the last valid one.
const_iterator cbegin() const
Const iterator to first element. "cbegin" matches the tr1 c++ standard.
FieldRes base
Convenience typedef for referring to base class.
Data_T value_type
Allows us to reference the template class.
std::vector< Ptr > Vec
This is a convenience typedef for the list that Field3DInputFile::readScalarLayers() and Field3DInput...
static const char * staticClassName()
Represents the mapping of a field by a matrix transform.
WritableField< Data_T > base
void setSize(const V3i &size)
Resizes the object.
void matchDefinition(FieldRes::Ptr fieldToMatch)
Sets up this field so that resolution and mapping matches the other.
ResizableField< Data_T > class_type
DEFINE_FIELD_RTTI_ABSTRACT_CLASS
static TemplatedFieldType< ResizableField< Data_T > > ms_classType
static const char * staticClassType()
virtual void sizeChanged()
Subclasses should re-implement this if they need to perform memory allocations, etc....
boost::intrusive_ptr< ResizableField > Ptr
void copyFrom(typename Field< Data_T >::Ptr other)
Copies the data from another Field, also resizes.
static const char * staticClassName()
Box3i m_window
Window to traverse.
iterator(WritableField< Data_T > &field, const Box3i &window, const V3i ¤tPos)
WritableField< Data_T > & m_field
Reference to field being iterated over.
WritableField< Data_T > class_type
boost::intrusive_ptr< WritableField > Ptr
static const char * staticClassType()
iterator end()
Iterator pointing one element past the last valid one.
virtual Data_T & lvalue(int i, int j, int k)=0
Write access to a voxel. The coordinates are global coordinates.
DEFINE_FIELD_RTTI_ABSTRACT_CLASS
static TemplatedFieldType< WritableField< Data_T > > ms_classType
static const char * staticClassName()
virtual void clear(const Data_T &value)
Clears all the voxels in the storage. Should be re-implemented by subclasses that can provide a more ...
iterator begin()
Iterator to first element.
void advance(Iter_T &iter, int num)
Namespace for Exception objects.
FIELD3D_API void print(Severity severity, const std::string &message)
Sends the string to the assigned output, prefixing the message with the severity.
#define FIELD3D_NAMESPACE_HEADER_CLOSE
static std::string name()
Used to return a string for the name of a templated field.