11 #ifndef __GT_DataArray__
12 #define __GT_DataArray__
48 virtual const char *className()
const = 0;
57 virtual GT_Size entries()
const = 0;
66 virtual GT_Size getTupleSize()
const = 0;
70 virtual int64 getMemoryUsage()
const = 0;
73 virtual GT_Type getTypeInfo()
const;
83 virtual bool isValid()
const {
return true; }
104 {
return getI32(offset, idx); }
106 {
return getI32(offset, idx); }
109 {
return getI32(offset, idx); }
112 {
return getF32(offset, idx); }
115 {
return getF32(offset, idx); }
159 template <
typename T>
165 virtual GT_Size getStringIndexCount()
const = 0;
192 int tuple_idx=0)
const;
226 { doImportArray(idx,
data); }
228 { doImportArray(idx,
data); }
230 { doImportArray(idx,
data); }
232 { doImportArray(idx,
data); }
234 { doImportArray(idx,
data); }
236 { doImportArray(idx,
data); }
238 { doImportArray(idx,
data); }
240 { doImportArray(idx,
data); }
242 { getSA(
data, idx); }
246 if (GTisFloat(getStorage()))
247 doImportQuantized(idx,
data,
size, black, white);
277 int tsize,
int stride=-1)
const
278 { doFillArray(data, start, length, tsize,
stride); }
280 int tsize,
int stride=-1)
const
281 { doFillArray(data, start, length, tsize,
stride); }
283 int tsize,
int stride=-1)
const
284 { doFillArray(data, start, length, tsize,
stride); }
286 int tsize,
int stride=-1)
const
287 { doFillArray(data, start, length, tsize,
stride); }
289 int tsize,
int stride=-1)
const
290 { doFillArray(data, start, length, tsize,
stride); }
292 int tsize,
int stride=-1)
const
293 { doFillArray(data, start, length, tsize,
stride); }
295 int tsize,
int stride=-1)
const
296 { doFillArray(data, start, length, tsize,
stride); }
302 if(GTisFloat(getStorage()))
303 doFillQuantizedArray(data, start, length, tsize,
306 doFillArray(data, start, length, tsize,
stride);
313 doFillVec3BBox(dest, start, length, bbox,
320 doFillVec3BBox(dest, start, length, bbox,
331 { doFillArrayAttr(data, sizes, start, length); }
334 { doFillArrayAttr(data, sizes, start, length); }
337 { doFillArrayAttr(data, sizes, start, length); }
340 { doFillArrayAttr(data, sizes, start, length); }
343 { doFillArrayAttr(data, sizes, start, length); }
346 { doFillArrayAttr(data, sizes, start, length); }
349 { doFillArrayAttr(data, sizes, start, length); }
352 { doFillArrayAttr(data, sizes, start, length); }
357 int tsize,
int nrepeats,
361 doExtendedQuantizedFill(data, start, length, tsize,
362 nrepeats,
stride, black, white);
374 int tsize,
int nrepeats,
int stride=-1)
const
376 t_extendedFill(data, start, length, tsize,
380 int tsize,
int nrepeats,
int stride=-1)
const
382 t_extendedFill(data, start, length, tsize,
386 int tsize,
int nrepeats,
int stride=-1)
const
388 t_extendedFill(data, start, length, tsize,
392 int tsize,
int nrepeats,
int stride=-1)
const
394 t_extendedFill(data, start, length, tsize,
398 int tsize,
int nrepeats,
int stride=-1)
const
400 t_extendedFill(data, start, length, tsize,
404 int tsize,
int nrepeats,
int stride=-1)
const
406 t_extendedFill(data, start, length, tsize,
410 int tsize,
int nrepeats,
int stride=-1)
const
412 t_extendedFill(data, start, length, tsize,
416 int tsize,
int nrepeats,
int stride=-1)
const
418 t_extendedFill(data, start, length, tsize,
439 virtual void getRange(
exint &lo,
exint &hi,
int tuple_idx=0)
const;
440 virtual void getRange(
fpreal &lo,
fpreal &hi,
int tidx=0)
const;
473 for (
int i = 0,
n = getTupleSize(); i <
n; ++i)
482 return computeMinMax(min, max);
486 int tsize = getTupleSize();
489 if (
min[0] <= max[0] &&
min[1] <= max[1] &&
min[2] <= max[2])
502 {
return size >= (((
int64)1) << 31); }
505 void dumpValues(
const char *msg=NULL)
const;
515 static void *
operator new(
size_t size);
516 static void *
operator new(
size_t size,
void *
p);
517 static void operator delete(
void *
p,
size_t size);
533 const char *attrib_name,
535 const int expected_size) {}
544 , myTupleSize(array.getTupleSize())
547 for (
int j = 0; j < myTupleSize; ++j)
554 : myArray(src.myArray)
555 , myTupleSize(src.myTupleSize)
558 std::copy(src.myMin, src.myMin+myTupleSize, myMin);
559 std::copy(src.myMax, src.myMax+myTupleSize, myMax);
563 if (myMin != myMinBuffer)
572 for (
GT_Size i = range.begin(),
n = range.end(); i <
n; ++i)
574 myArray.import(i, myPos, myTupleSize);
575 for (
int j = 0; j < myTupleSize; ++j)
577 myMin[j] =
SYSmin(myMin[j], myPos[j]);
578 myMax[j] =
SYSmax(myMax[j], myPos[j]);
584 for (
int j = 0; j < myTupleSize; ++j)
586 min[j] =
SYSmin(min[j], myMin[j]);
587 max[j] =
SYSmax(max[j], myMax[j]);
592 for (
int j = 0; j < myTupleSize; ++j)
594 myMin[j] =
SYSmin(myMin[j], src.myMin[j]);
595 myMax[j] =
SYSmax(myMax[j], src.myMax[j]);
601 if (myTupleSize > 16)
636 return size == 0 ? tuple_size :
SYSmin(size, tuple_size);
663 int tuple_size,
int stride)
const
664 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
667 int tuple_size,
int stride)
const
668 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
670 int tuple_size,
int stride)
const
671 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
673 int tuple_size,
int stride)
const
674 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
676 int tuple_size,
int stride)
const
677 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
679 int tuple_size,
int stride)
const
680 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
682 int tuple_size,
int stride)
const
683 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
685 int tuple_size,
int stride)
const
686 { t_extendedFill(data, start, length, tuple_size, 1, stride); }
689 { t_extendedFillArray(data, sizes, start, length); }
692 { t_extendedFillArray(data, sizes, start, length); }
695 { t_extendedFillArray(data, sizes, start, length); }
698 { t_extendedFillArray(data, sizes, start, length); }
701 { t_extendedFillArray(data, sizes, start, length); }
704 { t_extendedFillArray(data, sizes, start, length); }
707 { t_extendedFillArray(data, sizes, start, length); }
710 { t_extendedFillArray(data, sizes, start, length); }
714 int tuple_size,
int stride,
717 doExtendedQuantizedFill(data, start, length, tuple_size,
718 1, stride, black, white);
720 virtual void doExtendedQuantizedFill(
uint8 *
data,
722 int tuple_size,
int nrepeats,
int stride,
726 template <
typename T_POD>
740 : myArray(src.myArray)
743 , myStart(src.myStart)
744 , myStride(src.myStride)
749 exint i = range.begin();
750 T_POD *dest = myData + i*myStride;
751 for (; i != range.end(); ++i, dest += myStride)
753 myArray.import(i+myStart, dest, 3);
754 myBox.enlargeBounds(dest[0], dest[1], dest[2]);
759 myBox.enlargeBounds(src.myBox);
773 stride =
SYSmax(stride, 3);
781 stride =
SYSmax(stride, 3);
789 template <
typename T_POD>
void
791 int tsize,
int nrepeats,
int stride)
const;
794 template <
typename T_POD>
void
802 template <
typename T,
int tuplesize>
class VectorPODAccessor
809 array.
get(offset, result.data(), tuplesize);
843 template <
typename T,
int FAKE>
class TypeInfo {};
849 template <
int FAKE>
class TypeInfo<
int32, FAKE>
850 {
public:
typedef I32Accessor Accessors; };
851 template <
int FAKE>
class TypeInfo<
int64, FAKE>
852 {
public:
typedef I64Accessor Accessors; };
853 template <
int FAKE>
class TypeInfo<
fpreal16, FAKE>
854 {
public:
typedef F16Accessor Accessors; };
855 template <
int FAKE>
class TypeInfo<
fpreal32, FAKE>
856 {
public:
typedef F32Accessor Accessors; };
857 template <
int FAKE>
class TypeInfo<
fpreal64, FAKE>
858 {
public:
typedef F64Accessor Accessors; };
860 template <
int FAKE>
class TypeInfo<
UT_Vector2F, FAKE>
861 {
public:
typedef VectorPODAccessor<UT_Vector2F, 2> Accessors; };
862 template <
int FAKE>
class TypeInfo<
UT_Vector2D, FAKE>
863 {
public:
typedef VectorPODAccessor<UT_Vector2D, 2> Accessors; };
864 template <
int FAKE>
class TypeInfo<
UT_Vector3F, FAKE>
865 {
public:
typedef VectorPODAccessor<UT_Vector3F, 3> Accessors; };
866 template <
int FAKE>
class TypeInfo<
UT_Vector3D, FAKE>
867 {
public:
typedef VectorPODAccessor<UT_Vector3D, 3> Accessors; };
868 template <
int FAKE>
class TypeInfo<
UT_Vector4F, FAKE>
869 {
public:
typedef VectorPODAccessor<UT_Vector4F, 4> Accessors; };
870 template <
int FAKE>
class TypeInfo<
UT_Vector4D, FAKE>
871 {
public:
typedef VectorPODAccessor<UT_Vector4D, 4> Accessors; };
872 template <
int FAKE>
class TypeInfo<
UT_Matrix3F, FAKE>
873 {
public:
typedef VectorPODAccessor<UT_Matrix3F, 9> Accessors; };
874 template <
int FAKE>
class TypeInfo<
UT_Matrix3D, FAKE>
875 {
public:
typedef VectorPODAccessor<UT_Matrix3D, 9> Accessors; };
876 template <
int FAKE>
class TypeInfo<
UT_Matrix4F, FAKE>
877 {
public:
typedef VectorPODAccessor<UT_Matrix4F, 16> Accessors; };
878 template <
int FAKE>
class TypeInfo<
UT_Matrix4D, FAKE>
879 {
public:
typedef VectorPODAccessor<UT_Matrix4D, 16> Accessors; };
883 template <
typename T>
T
885 {
return TypeInfo<T, 0>::Accessors::getValue(*
this, index); }
887 template <
typename T>
T
890 return (1-t)*getValue<T>(i0) + t*getValue<T>(i1);
893 template <
typename T>
T
897 T l = (1-
v)*getValue<T>(u0v0) + v*getValue<T>(u0v1);
898 T r = (1-
v)*getValue<T>(u1v0) + v*getValue<T>(u1v1);
899 return (1-u)*l + u*
r;
SYS_HashType hash() const
virtual void updateGeoDetail(const GU_ConstDetailHandle &dtl, const char *attrib_name, GT_Owner attrib_owner, const int expected_size)
Update cached data, in case the underlying attribute changed.
virtual void extendedFill(int16 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
GLboolean GLboolean GLboolean b
virtual bool getIA32(UT_ValArray< int32 > &a, GT_Offset offset) const
virtual void doFillQuantizedArray(uint8 *data, GT_Offset start, GT_Size length, int tuple_size, int stride, fpreal black, fpreal white) const
virtual bool isValid() const
Data array is valid; can be sampled from.
void fillArray(UT_Array< fpreal64 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual fpreal16 getF16(GT_Offset offset, int idx=0) const
virtual void extendedFill(int32 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
void fillArray(fpreal64 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
Nested class to perform filling for a POD array.
virtual bool getFA64(UT_ValArray< fpreal64 > &a, GT_Offset offset) const
virtual fpreal64 getF64(GT_Offset offset, int idx=0) const
T lerpValue(GT_Offset i0, GT_Offset i1, fpreal t) const
virtual void fillStringArray(UT_StringArray &data, UT_ValArray< int > &sizes, GT_Offset start, GT_Size length) const
OIIO_UTIL_API bool copy(string_view from, string_view to, std::string &err)
void join(const fillV3BoxTask< T_POD > &src)
void fillArray(UT_Array< fpreal32 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArray(int16 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
bool enlargeBounds(UT_BoundingBox &b) const
virtual fpreal32 getF32(GT_Offset offset, int idx=0) const =0
virtual const void * getBackingData() const
const UT_BoundingBox & box() const
virtual int64 getI64(GT_Offset offset, int idx=0) const
std::size_t SYS_HashType
Define the type for hash values.
static bool isBigInteger(GT_Size size)
Quick & dirty test to see if a size is bigger than a 32 bit int.
virtual bool getUA8(UT_ValArray< uint8 > &a, GT_Offset offset) const
void fillArray(int16 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
virtual void extendedFill(fpreal16 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
Class which writes ASCII or binary JSON streams.
minMaxTask(const GT_DataArray &array)
virtual void extendedFill(int64 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
A reference counter base class for use with UT_IntrusivePtr.
void fillArray(UT_Array< int16 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArray(int64 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
virtual GT_Size itemSize(GT_Offset) const
Return the number of elements in the array for the given item.
virtual void doFillVec3BBox(fpreal64 *dest, GT_Offset start, GT_Size length, UT_BoundingBoxD &bbox, int, int stride)
virtual void extendedFill(fpreal32 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
virtual void doFillVec3BBox(fpreal32 *dest, GT_Offset start, GT_Size length, UT_BoundingBoxF &bbox, int, int stride)
void fillArray(fpreal32 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
virtual bool getIA64(UT_ValArray< int64 > &a, GT_Offset offset) const
virtual bool computeMinMax(fpreal64 *min, fpreal64 *max) const
virtual bool getIA16(UT_ValArray< int16 > &a, GT_Offset offset) const
GLubyte GLubyte GLubyte GLubyte w
virtual void extendedFill(int8 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
virtual void doFillArrayAttr(UT_Array< fpreal16 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
void getResult(fpreal64 *min, fpreal64 *max) const
virtual void doFillArrayAttr(UT_Array< int32 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
Abstract data class for an array of float, int or string data.
virtual const uint8 * get(GT_Offset i, uint8 *store, int sz) const
virtual void extendedFill(uint8 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
UT_IntrusivePtr< GT_DataArray > GT_DataArrayHandle
virtual void extendedFill(fpreal64 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1) const
virtual int64 getDataId() const
fillV3BoxTask(const GT_DataArray &array, T_POD *data, GT_Offset start, int stride)
void fillArray(UT_Array< int8 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArray(int8 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
GLboolean GLboolean GLboolean GLboolean a
virtual bool getFA32(UT_ValArray< fpreal32 > &a, GT_Offset offset) const
GLsizei const GLchar *const * string
GLsizei GLenum const void * indices
virtual bool getIA8(UT_ValArray< int8 > &a, GT_Offset offset) const
virtual bool getPointerAliasing(const void *data) const
Return "true" if there's pointer aliasing.
GLdouble GLdouble GLdouble z
virtual void doFillArrayAttr(UT_Array< int8 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArrayAttr(UT_Array< int16 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArray(uint8 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
virtual void extendedFillArray(uint8 *data, GT_Offset start, GT_Size length, int tsize, int nrepeats, int stride=-1, fpreal black=0, fpreal white=1) const
virtual bool getSA(UT_StringArray &a, GT_Offset offset) const
#define SYS_STATIC_FORCE_INLINE
T getValue(GT_Offset index) const
Public accessor for POD types.
GLsizei const GLchar *const * strings
void enlargeBounds(const UT_Vector3T< T > &min, const UT_Vector3T< T > &max)
void fillArray(fpreal16 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
fillV3BoxTask(fillV3BoxTask &src, UT_Split)
virtual void doFillArrayAttr(UT_Array< fpreal64 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
void copyDataId(const GT_DataArray &src)
void operator()(const UT_BlockedRange< GT_Size > &range)
minMaxTask(minMaxTask &src, UT_Split)
GLuint GLsizei GLsizei * length
void fillArray(int8 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
virtual bool getFA16(UT_ValArray< fpreal16 > &a, GT_Offset offset) const
virtual void doFillArray(fpreal16 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
void fillVec3BBox(fpreal64 *dest, GT_Offset start, GT_Size length, UT_BoundingBoxD &bbox, int tsize, int stride=-1)
virtual void doFillArray(fpreal32 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
virtual void doFillArrayAttr(UT_Array< fpreal32 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
bool getMinMax(fpreal64 *min, fpreal64 *max) const
Enlarge a bounding box with values of this 3-tuple array.
virtual int16 getI16(GT_Offset offset, int idx=0) const
void operator()(const UT_BlockedRange< exint > &range)
void fillVec3BBox(fpreal32 *dest, GT_Offset start, GT_Size length, UT_BoundingBoxF &bbox, int tsize, int stride=-1)
virtual bool hasArrayEntries() const
Returns "true" if each entry is an array.
void fillArray(UT_Array< int64 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArray(fpreal64 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
void fillArray(UT_Array< fpreal16 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
void fillArray(uint8 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1, fpreal black=0, fpreal white=1) const
virtual void doFillArrayAttr(UT_Array< int64 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
T bilerpValue(GT_Offset u0v0, GT_Offset u1v0, GT_Offset u0v1, GT_Offset u1v1, fpreal u, fpreal v)
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
void fillArray(int32 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
GLint GLenum GLboolean GLsizei stride
void fillArray(int64 *data, GT_Offset start, GT_Size length, int tsize, int stride=-1) const
virtual void doFillArray(int32 *data, GT_Offset start, GT_Size length, int tuple_size, int stride) const
void join(const minMaxTask &src)
virtual int32 getI32(GT_Offset offset, int idx=0) const =0
SYS_STATIC_FORCE_INLINE GT_Size fixImportTupleSize(GT_Size size, GT_Size tuple_size)
virtual int8 getI8(GT_Offset offset, int idx=0) const
virtual GT_Size getTupleSize() const =0
Number of elements for each array element.
void fillArray(UT_Array< uint8 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
virtual void doFillArrayAttr(UT_Array< uint8 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
Compute the min & max values for an array. This fails for strings.
virtual GT_Size getTotalArrayEntries() const
void UTparallelReduceLightItems(const Range &range, Body &body)
void fillArray(UT_Array< int32 > &data, UT_Array< int > &sizes, GT_Offset start, GT_Size length) const
PcpNodeRef_ChildrenIterator begin(const PcpNodeRef::child_const_range &r)
Support for range-based for loops for PcpNodeRef children ranges.