31 #ifndef OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 32 #define OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 37 #include <boost/scoped_array.hpp> 111 enum { isReal =
false };
113 static HalfT
convert(
const T& val) {
return val; }
116 enum { isReal =
true };
118 static HalfT
convert(
float val) {
return HalfT(val); }
121 enum { isReal =
true };
124 static HalfT
convert(
double val) {
return HalfT(
float(val)); }
127 enum { isReal =
true };
132 enum { isReal =
true };
138 enum { isReal =
true };
143 enum { isReal =
true };
186 is.read(reinterpret_cast<char*>(data),
sizeof(T) * count);
193 readData<std::string>(std::istream& is, std::string* data,
Index count, uint32_t )
195 for (
Index i = 0; i < count; ++i) {
201 std::string buffer(len+1,
' ');
202 is.read(&buffer[0], len+1 );
203 data[i].assign(buffer, 0, len);
215 static inline void read(std::istream& is, T* data,
Index count, uint32_t compression) {
216 readData(is, data, count, compression);
223 static inline void read(std::istream& is, T* data,
Index count, uint32_t compression) {
224 if (count < 1)
return;
225 std::vector<HalfT> halfData(count);
226 readData<HalfT>(is,
reinterpret_cast<HalfT*
>(&halfData[0]), count, compression);
228 std::copy(halfData.begin(), halfData.end(), data);
248 bloscToStream(os, reinterpret_cast<const char*>(data),
sizeof(T), count);
250 zipToStream(os, reinterpret_cast<const char*>(data),
sizeof(T) * count);
252 os.write(reinterpret_cast<const char*>(data),
sizeof(T) * count);
259 writeData<std::string>(std::ostream& os,
const std::string* data,
Index count,
262 for (
Index i = 0; i < count; ++i) {
263 const size_t len = data[i].size();
265 os.write(data[i].c_str(), len+1);
278 static inline void write(std::ostream& os,
const T* data,
Index count, uint32_t compression) {
286 static inline void write(std::ostream& os,
const T* data,
Index count, uint32_t compression) {
287 if (count < 1)
return;
289 std::vector<HalfT> halfData(count);
290 for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<T>::convert(data[i]);
291 writeData<HalfT>(os,
reinterpret_cast<const HalfT*
>(&halfData[0]), count, compression);
299 static inline void write(std::ostream& os,
const double* data,
Index count,
300 uint32_t compression)
302 if (count < 1)
return;
304 std::vector<HalfT> halfData(count);
305 for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<double>::convert(data[i]);
306 writeData<HalfT>(os,
reinterpret_cast<const HalfT*
>(&halfData[0]), count, compression);
327 template<
typename ValueT,
typename MaskT>
330 const MaskT& valueMask,
bool fromHalf)
340 is.read(reinterpret_cast<char*>(&metadata), 1);
343 ValueT background = zeroVal<ValueT>();
345 background = *
static_cast<const ValueT*
>(bgPtr);
347 ValueT inactiveVal1 = background;
348 ValueT inactiveVal0 =
356 is.read(reinterpret_cast<char*>(&inactiveVal0),
sizeof(ValueT));
359 is.read(reinterpret_cast<char*>(&inactiveVal1),
sizeof(ValueT));
370 selectionMask.load(is);
373 ValueT* tempBuf = destBuf;
374 boost::scoped_array<ValueT> scopedTempBuf;
376 Index tempCount = destCount;
380 tempCount = valueMask.countOn();
381 if (tempCount != destCount) {
384 scopedTempBuf.reset(
new ValueT[tempCount]);
385 tempBuf = scopedTempBuf.get();
393 readData<ValueT>(is, tempBuf, tempCount, compression);
399 if (maskCompressed && tempCount != destCount) {
403 for (
Index destIdx = 0, tempIdx = 0; destIdx < MaskT::SIZE; ++destIdx) {
404 if (valueMask.isOn(destIdx)) {
406 destBuf[destIdx] = tempBuf[tempIdx];
410 destBuf[destIdx] = (selectionMask.isOn(destIdx) ? inactiveVal1 : inactiveVal0);
429 template<
typename ValueT,
typename MaskT>
432 const MaskT& valueMask,
const MaskT& childMask,
bool toHalf)
436 static inline bool eq(
const ValueT& a,
const ValueT& b) {
445 Index tempCount = srcCount;
446 ValueT* tempBuf = srcBuf;
447 boost::scoped_array<ValueT> scopedTempBuf;
452 os.write(reinterpret_cast<const char*>(&metadata), 1);
460 const ValueT zero = zeroVal<ValueT>();
461 ValueT background = zero;
463 background = *
static_cast<const ValueT*
>(bgPtr);
467 ValueT inactiveVal[2] = { background, background };
468 int numUniqueInactiveVals = 0;
469 for (
typename MaskT::OffIterator it = valueMask.beginOff();
470 numUniqueInactiveVals < 3 && it; ++it)
475 if (childMask.isOn(idx))
continue;
477 const ValueT& val = srcBuf[idx];
478 const bool unique = !(
479 (numUniqueInactiveVals > 0 && Local::eq(val, inactiveVal[0])) ||
480 (numUniqueInactiveVals > 1 && Local::eq(val, inactiveVal[1]))
483 if (numUniqueInactiveVals < 2) inactiveVal[numUniqueInactiveVals] = val;
484 ++numUniqueInactiveVals;
490 if (numUniqueInactiveVals == 1) {
491 if (!Local::eq(inactiveVal[0], background)) {
498 }
else if (numUniqueInactiveVals == 2) {
500 if (!Local::eq(inactiveVal[0], background) && !Local::eq(inactiveVal[1], background)) {
505 }
else if (Local::eq(inactiveVal[1], background)) {
517 }
else if (Local::eq(inactiveVal[0], background)) {
523 std::swap(inactiveVal[0], inactiveVal[1]);
528 std::swap(inactiveVal[0], inactiveVal[1]);
532 }
else if (numUniqueInactiveVals > 2) {
536 os.write(reinterpret_cast<const char*>(&metadata), 1);
544 os.write(reinterpret_cast<const char*>(&inactiveVal[0]),
sizeof(ValueT));
547 os.write(reinterpret_cast<const char*>(&inactiveVal[1]),
sizeof(ValueT));
552 os.write(reinterpret_cast<const char*>(&truncatedVal),
sizeof(ValueT));
556 os.write(reinterpret_cast<const char*>(&truncatedVal),
sizeof(ValueT));
568 scopedTempBuf.reset(
new ValueT[srcCount]);
569 tempBuf = scopedTempBuf.get();
577 for (
typename MaskT::OnIterator it = valueMask.beginOn(); it; ++it, ++tempCount) {
578 tempBuf[tempCount] = srcBuf[it.pos()];
585 for (
Index srcIdx = 0; srcIdx < srcCount; ++srcIdx) {
586 if (valueMask.isOn(srcIdx)) {
587 tempBuf[tempCount] = srcBuf[srcIdx];
590 if (Local::eq(srcBuf[srcIdx], inactiveVal[1])) {
591 selectionMask.setOn(srcIdx);
595 assert(tempCount == valueMask.countOn());
598 selectionMask.save(os);
607 writeData(os, tempBuf, tempCount, compress);
615 #endif // OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED Vec3< float > Vec3s
Definition: Vec3.h:650
Definition: Compression.h:81
static void read(std::istream &is, T *data, Index count, uint32_t compression)
Definition: Compression.h:223
OPENVDB_API std::string compressionToString(uint32_t flags)
Return a string describing the given compression flags.
Definition: Compression.h:274
half HalfT
Definition: Compression.h:122
Vec2< double > Vec2d
Definition: Vec2.h:543
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition: Math.h:407
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:286
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
Definition: Compression.h:94
OPENVDB_API void bloscFromStream(std::istream &, char *data, size_t numBytes)
static HalfT convert(const Vec2d &val)
Definition: Compression.h:135
T truncateRealToHalf(const T &val)
Return the given value truncated to 16-bit float precision.
Definition: Compression.h:153
Vec3H HalfT
Definition: Compression.h:139
OPENVDB_API void unzipFromStream(std::istream &, char *data, size_t numBytes)
Definition: Compression.h:99
OPENVDB_API void bloscToStream(std::ostream &, const char *data, size_t valSize, size_t numVals)
Vec2H HalfT
Definition: Compression.h:133
OPENVDB_API const void * getGridBackgroundValuePtr(std::ios_base &)
Return a pointer to the background value of the grid currently being read from or written to the give...
static HalfT convert(float val)
Definition: Compression.h:118
Definition: Compression.h:80
Index32 Index
Definition: Types.h:58
static HalfT convert(const Vec3s &val)
Definition: Compression.h:140
Definition: Compression.h:97
#define OPENVDB_VERSION_NAME
Definition: version.h:43
Vec3< double > Vec3d
Definition: Vec3.h:651
void readCompressedValues(std::istream &is, ValueT *destBuf, Index destCount, const MaskT &valueMask, bool fromHalf)
Definition: Compression.h:329
OPENVDB_API void zipToStream(std::ostream &, const char *data, size_t numBytes)
Definition: version.h:110
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
void writeCompressedValues(std::ostream &os, ValueT *srcBuf, Index srcCount, const MaskT &valueMask, const MaskT &childMask, bool toHalf)
Definition: Compression.h:431
Definition: Exceptions.h:39
uint32_t Index32
Definition: Types.h:56
T HalfT
Definition: Compression.h:112
static HalfT convert(double val)
Definition: Compression.h:124
void writeData(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:245
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:278
Definition: Compression.h:96
static HalfT convert(const T &val)
Definition: Compression.h:113
void readData(std::istream &is, T *data, Index count, uint32_t compression)
Read data from a stream.
Definition: Compression.h:179
Definition: Compression.h:211
static HalfT convert(const Vec3d &val)
Definition: Compression.h:146
Definition: Compression.h:78
static HalfT convert(const Vec2s &val)
Definition: Compression.h:129
RealToHalf< T >::HalfT HalfT
Definition: Compression.h:222
Vec3H HalfT
Definition: Compression.h:144
RealToHalf and its specializations define a mapping from floating-point data types to analogous half ...
Definition: Compression.h:110
T negative(const T &val)
Return the unary negation of the given value.
Definition: Math.h:116
static void read(std::istream &is, T *data, Index count, uint32_t compression)
Definition: Compression.h:215
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:71
Definition: Compression.h:79
Vec2< float > Vec2s
Definition: Vec2.h:542
Definition: Compression.h:98
OPENVDB_API uint32_t getDataCompression(std::ios_base &)
Return a bitwise OR of compression option flags (COMPRESS_ZIP, COMPRESS_ACTIVE_MASK, etc.) specifying whether and how input data is compressed or output data should be compressed.
Definition: Compression.h:100
Vec2H HalfT
Definition: Compression.h:128
half HalfT
Definition: Compression.h:117
Definition: Compression.h:95
RealToHalf< T >::HalfT HalfT
Definition: Compression.h:285