EmptyField.h
Go to the documentation of this file.
//----------------------------------------------------------------------------//
/*
* Copyright (c) 2009 Sony Pictures Imageworks Inc
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution. Neither the name of Sony Pictures Imageworks nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
#ifndef _INCLUDED_Field3D_EmptyField_H_
#define _INCLUDED_Field3D_EmptyField_H_
#include <vector>
#include <boost/lexical_cast.hpp>
#include "Field.h"
//----------------------------------------------------------------------------//
#include "ns.h"
FIELD3D_NAMESPACE_OPEN
//----------------------------------------------------------------------------//
// gets rid of warnings (N.B. not on clang, where self-assignment is warned!)
#ifdef __clang__
# define UNUSED(p)
#else
# define UNUSED(p) ((p)=(p))
#endif
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
template <class Data_T>
class EmptyField
: public ResizableField<Data_T>
{
public:
// Typedefs ------------------------------------------------------------------
typedef boost::intrusive_ptr<EmptyField> Ptr;
typedef std::vector<Ptr> Vec;
// Constructors --------------------------------------------------------------
EmptyField();
// \}
// Main methods --------------------------------------------------------------
virtual void clear(const Data_T &value);
const Data_T& constantvalue() const;
void setConstantvalue(const Data_T &val);
// From Field base class -------------------------------------------------
virtual Data_T value(int i, int j, int k) const;
virtual long long int memSize() const;
// RTTI replacement ----------------------------------------------------------
typedef EmptyField<Data_T> class_type;
DEFINE_FIELD_RTTI_CONCRETE_CLASS
static const char *staticClassName()
{
return staticClassType();
}
static const char *staticClassType()
{
return "EmptyField";
}
// From WritableField base class -----------------------------------------
virtual Data_T& lvalue(int i, int j, int k);
// From FieldBase ------------------------------------------------------------
FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
virtual FieldBase::Ptr clone() const
{ return Ptr(new EmptyField(*this)); }
protected:
// Data members --------------------------------------------------------------
Data_T m_default;
Data_T m_ignoredData;
Data_T m_constantData;
private:
// Typedefs ------------------------------------------------------------------
typedef ResizableField<Data_T> base;
};
//----------------------------------------------------------------------------//
// EmptyField implementations
//----------------------------------------------------------------------------//
template <class Data_T>
EmptyField<Data_T>::EmptyField()
: base()
{
// Empty
}
//----------------------------------------------------------------------------//
template <class Data_T>
void EmptyField<Data_T>::clear(const Data_T &value)
{
m_constantData = m_default = value;
}
//----------------------------------------------------------------------------//
template <class Data_T>
Data_T EmptyField<Data_T>::value(int i, int j, int k) const
{
assert (i >= base::m_dataWindow.min.x);
assert (i <= base::m_dataWindow.max.x);
assert (j >= base::m_dataWindow.min.y);
assert (j <= base::m_dataWindow.max.y);
assert (k >= base::m_dataWindow.min.z);
assert (k <= base::m_dataWindow.max.z);
UNUSED(i);
UNUSED(j);
UNUSED(k);
// Access data
return m_default;
}
//----------------------------------------------------------------------------//
template <class Data_T>
long long int EmptyField<Data_T>::memSize() const
{
long long int superClassMemSize = base::memSize();
return sizeof(*this) + superClassMemSize;
}
//----------------------------------------------------------------------------//
template <class Data_T>
Data_T& EmptyField<Data_T>::lvalue(int i, int j, int k)
{
assert (i >= base::m_dataWindow.min.x);
assert (i <= base::m_dataWindow.max.x);
assert (j >= base::m_dataWindow.min.y);
assert (j <= base::m_dataWindow.max.y);
assert (k >= base::m_dataWindow.min.z);
assert (k <= base::m_dataWindow.max.z);
UNUSED(i);
UNUSED(j);
UNUSED(k);
// Access data
return m_ignoredData;
}
//----------------------------------------------------------------------------//
template <class Data_T>
inline void EmptyField<Data_T>::setConstantvalue(const Data_T &val)
{
m_constantData = val;
}
//----------------------------------------------------------------------------//
template <class Data_T>
inline const Data_T& EmptyField<Data_T>::constantvalue() const
{
return m_constantData;
}
//----------------------------------------------------------------------------//
// Typedefs
//----------------------------------------------------------------------------//
typedef EmptyField<float> Proxy;
typedef EmptyField<float>::Ptr ProxyPtr;
typedef std::vector<ProxyPtr> Proxies;
//----------------------------------------------------------------------------//
FIELD3D_NAMESPACE_HEADER_CLOSE
//----------------------------------------------------------------------------//
#undef UNUSED
//----------------------------------------------------------------------------//
#endif // Include guard
Proxies
std::vector< ProxyPtr > Proxies
Definition EmptyField.h:267
Proxy
EmptyField< float > Proxy
Definition EmptyField.h:265
ProxyPtr
EmptyField< float >::Ptr ProxyPtr
Definition EmptyField.h:266
UNUSED
#define UNUSED(p)
Definition EmptyField.h:65
Field.h
Contains Field, WritableField and ResizableField classes.
FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
#define FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
Definition Field.h:473
DEFINE_FIELD_RTTI_CONCRETE_CLASS
#define DEFINE_FIELD_RTTI_CONCRETE_CLASS
Definition RefCount.h:84
EmptyField
This subclass of Field does not store any data.
Definition EmptyField.h:88
EmptyField::constantvalue
const Data_T & constantvalue() const
Returns the constant value.
Definition EmptyField.h:256
EmptyField< float >::m_ignoredData
float m_ignoredData
Definition EmptyField.h:165
EmptyField::setConstantvalue
void setConstantvalue(const Data_T &val)
Sets the constant value.
Definition EmptyField.h:248
EmptyField::clone
virtual FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION FieldBase::Ptr clone() const
Returns a pointer to a copy of the field, pure virtual so ensure derived classes properly implement i...
Definition EmptyField.h:153
EmptyField::memSize
virtual long long int memSize() const
Returns the memory usage (in bytes).
Definition EmptyField.h:219
EmptyField::Ptr
boost::intrusive_ptr< EmptyField > Ptr
Definition EmptyField.h:93
EmptyField::lvalue
virtual Data_T & lvalue(int i, int j, int k)
Write access to a voxel. The coordinates are global coordinates.
Definition EmptyField.h:228
EmptyField::base
ResizableField< Data_T > base
Definition EmptyField.h:173
EmptyField::EmptyField
EmptyField()
Constructs an empty buffer.
Definition EmptyField.h:182
EmptyField< float >::value
virtual float value(int i, int j, int k) const
EmptyField::staticClassName
static DEFINE_FIELD_RTTI_CONCRETE_CLASS const char * staticClassName()
Definition EmptyField.h:129
EmptyField::staticClassType
static const char * staticClassType()
Definition EmptyField.h:134
EmptyField< float >::m_constantData
float m_constantData
Definition EmptyField.h:167
EmptyField< float >::m_default
float m_default
Definition EmptyField.h:163
EmptyField::Vec
std::vector< Ptr > Vec
Definition EmptyField.h:94
EmptyField::clear
virtual void clear(const Data_T &value)
Clears all the voxels in the storage.
Definition EmptyField.h:191
EmptyField::class_type
EmptyField< Data_T > class_type
Definition EmptyField.h:126
FieldBase::Ptr
boost::intrusive_ptr< FieldBase > Ptr
Definition Field.h:97
FieldRes::m_dataWindow
Box3i m_dataWindow
Defines the area where data is allocated. This should be treated as a closed (i.e....
Definition Field.h:310
FieldRes::memSize
virtual long long int memSize() const
Returns the memory usage (in bytes).
Definition Field.h:279
ResizableField
Definition Field.h:835
FIELD3D_NAMESPACE_OPEN
Definition FieldMapping.cpp:74
ns.h
FIELD3D_NAMESPACE_HEADER_CLOSE
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition ns.h:58