summaryrefslogtreecommitdiff
path: root/src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h')
-rw-r--r--src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h412
1 files changed, 412 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h b/src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h
new file mode 100644
index 0000000..ff6bf75
--- /dev/null
+++ b/src/mesh/assimp-master/contrib/Open3DGC/o3dgcCommon.h
@@ -0,0 +1,412 @@
+/*
+Copyright (c) 2013 Khaled Mammou - Advanced Micro Devices, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#pragma once
+#ifndef O3DGC_COMMON_H
+#define O3DGC_COMMON_H
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+
+namespace o3dgc
+{
+ typedef float Real;
+ const double O3DGC_MAX_DOUBLE = 1.79769e+308;
+ const long O3DGC_MIN_LONG = -2147483647;
+ const long O3DGC_MAX_LONG = 2147483647;
+ const long O3DGC_MAX_UCHAR8 = 255;
+ const long O3DGC_MAX_TFAN_SIZE = 256;
+ const unsigned long O3DGC_MAX_ULONG = 4294967295;
+
+ const unsigned long O3DGC_SC3DMC_START_CODE = 0x00001F1;
+ const unsigned long O3DGC_DV_START_CODE = 0x00001F2;
+ const unsigned long O3DGC_SC3DMC_MAX_NUM_FLOAT_ATTRIBUTES = 256;
+ const unsigned long O3DGC_SC3DMC_MAX_NUM_INT_ATTRIBUTES = 256;
+ const unsigned long O3DGC_SC3DMC_MAX_DIM_ATTRIBUTES = 32;
+
+ const unsigned long O3DGC_SC3DMC_MAX_PREDICTION_NEIGHBORS = 2;
+ const unsigned long O3DGC_SC3DMC_MAX_PREDICTION_SYMBOLS = 257;
+
+ enum O3DGCEndianness
+ {
+ O3DGC_BIG_ENDIAN = 0,
+ O3DGC_LITTLE_ENDIAN = 1
+ };
+ enum O3DGCErrorCode
+ {
+ O3DGC_OK,
+ O3DGC_ERROR_BUFFER_FULL,
+ O3DGC_ERROR_CREATE_FILE,
+ O3DGC_ERROR_OPEN_FILE,
+ O3DGC_ERROR_READ_FILE,
+ O3DGC_ERROR_CORRUPTED_STREAM,
+ O3DGC_ERROR_NON_SUPPORTED_FEATURE
+ };
+ enum O3DGCSC3DMCBinarization
+ {
+ O3DGC_SC3DMC_BINARIZATION_FL = 0, // Fixed Length (not supported)
+ O3DGC_SC3DMC_BINARIZATION_BP = 1, // BPC (not supported)
+ O3DGC_SC3DMC_BINARIZATION_FC = 2, // 4 bits Coding (not supported)
+ O3DGC_SC3DMC_BINARIZATION_AC = 3, // Arithmetic Coding (not supported)
+ O3DGC_SC3DMC_BINARIZATION_AC_EGC = 4, // Arithmetic Coding & EGCk
+ O3DGC_SC3DMC_BINARIZATION_ASCII = 5 // Arithmetic Coding & EGCk
+ };
+ enum O3DGCStreamType
+ {
+ O3DGC_STREAM_TYPE_UNKOWN = 0,
+ O3DGC_STREAM_TYPE_ASCII = 1,
+ O3DGC_STREAM_TYPE_BINARY = 2
+ };
+ enum O3DGCSC3DMCQuantizationMode
+ {
+ O3DGC_SC3DMC_DIAG_BB = 0, // supported
+ O3DGC_SC3DMC_MAX_ALL_DIMS = 1, // supported
+ O3DGC_SC3DMC_MAX_SEP_DIM = 2 // supported
+ };
+ enum O3DGCSC3DMCPredictionMode
+ {
+ O3DGC_SC3DMC_NO_PREDICTION = 0, // supported
+ O3DGC_SC3DMC_DIFFERENTIAL_PREDICTION = 1, // supported
+ O3DGC_SC3DMC_XOR_PREDICTION = 2, // not supported
+ O3DGC_SC3DMC_ADAPTIVE_DIFFERENTIAL_PREDICTION = 3, // not supported
+ O3DGC_SC3DMC_CIRCULAR_DIFFERENTIAL_PREDICTION = 4, // not supported
+ O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION = 5, // supported
+ O3DGC_SC3DMC_SURF_NORMALS_PREDICTION = 6 // supported
+ };
+ enum O3DGCSC3DMCEncodingMode
+ {
+ O3DGC_SC3DMC_ENCODE_MODE_QBCR = 0, // not supported
+ O3DGC_SC3DMC_ENCODE_MODE_SVA = 1, // not supported
+ O3DGC_SC3DMC_ENCODE_MODE_TFAN = 2, // supported
+ };
+ enum O3DGCDVEncodingMode
+ {
+ O3DGC_DYNAMIC_VECTOR_ENCODE_MODE_LIFT = 0
+ };
+ enum O3DGCIFSFloatAttributeType
+ {
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_UNKOWN = 0,
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_POSITION = 1,
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_NORMAL = 2,
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_COLOR = 3,
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD = 4,
+ O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_WEIGHT = 5
+
+ };
+ enum O3DGCIFSIntAttributeType
+ {
+ O3DGC_IFS_INT_ATTRIBUTE_TYPE_UNKOWN = 0,
+ O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX = 1,
+ O3DGC_IFS_INT_ATTRIBUTE_TYPE_JOINT_ID = 2,
+ O3DGC_IFS_INT_ATTRIBUTE_TYPE_INDEX_BUFFER_ID = 3
+ };
+
+ template<class T>
+ inline const T absolute(const T& a)
+ {
+ return (a < (T)(0)) ? -a : a;
+ }
+ template<class T>
+ inline const T min(const T& a, const T& b)
+ {
+ return (b < a) ? b : a;
+ }
+ template<class T>
+ inline const T max(const T& a, const T& b)
+ {
+ return (b > a) ? b : a;
+ }
+ template<class T>
+ inline void swap(T& a, T& b)
+ {
+ T tmp = a;
+ a = b;
+ b = tmp;
+ }
+ inline double log2( double n )
+ {
+ return log(n) / log(2.0);
+ }
+
+ inline O3DGCEndianness SystemEndianness()
+ {
+ unsigned long num = 1;
+ return ( *((char *)(&num)) == 1 )? O3DGC_LITTLE_ENDIAN : O3DGC_BIG_ENDIAN ;
+ }
+ class SC3DMCStats
+ {
+ public:
+ SC3DMCStats(void)
+ {
+ memset(this, 0, sizeof(SC3DMCStats));
+ };
+ ~SC3DMCStats(void){};
+
+ double m_timeCoord;
+ double m_timeNormal;
+ double m_timeCoordIndex;
+ double m_timeFloatAttribute[O3DGC_SC3DMC_MAX_NUM_FLOAT_ATTRIBUTES];
+ double m_timeIntAttribute [O3DGC_SC3DMC_MAX_NUM_INT_ATTRIBUTES ];
+ double m_timeReorder;
+
+ unsigned long m_streamSizeCoord;
+ unsigned long m_streamSizeNormal;
+ unsigned long m_streamSizeCoordIndex;
+ unsigned long m_streamSizeFloatAttribute[O3DGC_SC3DMC_MAX_NUM_FLOAT_ATTRIBUTES];
+ unsigned long m_streamSizeIntAttribute [O3DGC_SC3DMC_MAX_NUM_INT_ATTRIBUTES ];
+
+ };
+ typedef struct
+ {
+ long m_a;
+ long m_b;
+ long m_c;
+ } SC3DMCTriplet;
+
+ typedef struct
+ {
+ SC3DMCTriplet m_id;
+ long m_pred[O3DGC_SC3DMC_MAX_DIM_ATTRIBUTES];
+ } SC3DMCPredictor;
+
+ inline bool operator< (const SC3DMCTriplet& lhs, const SC3DMCTriplet& rhs)
+ {
+ if (lhs.m_c != rhs.m_c)
+ {
+ return (lhs.m_c < rhs.m_c);
+ }
+ else if (lhs.m_b != rhs.m_b)
+ {
+ return (lhs.m_b < rhs.m_b);
+ }
+ return (lhs.m_a < rhs.m_a);
+ }
+ inline bool operator== (const SC3DMCTriplet& lhs, const SC3DMCTriplet& rhs)
+ {
+ return (lhs.m_c == rhs.m_c && lhs.m_b == rhs.m_b && lhs.m_a == rhs.m_a);
+ }
+
+
+ // fix me: optimize this function (e.g., binary search)
+ inline unsigned long Insert(SC3DMCTriplet e, unsigned long & nPred, SC3DMCPredictor * const list)
+ {
+ unsigned long pos = 0xFFFFFFFF;
+ bool foundOrInserted = false;
+ for (unsigned long j = 0; j < nPred; ++j)
+ {
+ if (e == list[j].m_id)
+ {
+ foundOrInserted = true;
+ break;
+ }
+ else if (e < list[j].m_id)
+ {
+ if (nPred < O3DGC_SC3DMC_MAX_PREDICTION_NEIGHBORS)
+ {
+ ++nPred;
+ }
+ for (unsigned long h = nPred-1; h > j; --h)
+ {
+ list[h] = list[h-1];
+ }
+ list[j].m_id = e;
+ pos = j;
+ foundOrInserted = true;
+ break;
+ }
+ }
+ if (!foundOrInserted && nPred < O3DGC_SC3DMC_MAX_PREDICTION_NEIGHBORS)
+ {
+ pos = nPred;
+ list[nPred++].m_id = e;
+ }
+ return pos;
+ }
+ template <class T>
+ inline void SphereToCube(const T x, const T y, const T z,
+ T & a, T & b, char & index)
+ {
+ T ax = absolute(x);
+ T ay = absolute(y);
+ T az = absolute(z);
+ if (az >= ax && az >= ay)
+ {
+ if (z >= (T)(0))
+ {
+ index = 0;
+ a = x;
+ b = y;
+ }
+ else
+ {
+ index = 1;
+ a = -x;
+ b = -y;
+ }
+ }
+ else if (ay >= ax && ay >= az)
+ {
+ if (y >= (T)(0))
+ {
+ index = 2;
+ a = z;
+ b = x;
+ }
+ else
+ {
+ index = 3;
+ a = -z;
+ b = -x;
+ }
+ }
+ else if (ax >= ay && ax >= az)
+ {
+ if (x >= (T)(0))
+ {
+ index = 4;
+ a = y;
+ b = z;
+ }
+ else
+ {
+ index = 5;
+ a = -y;
+ b = -z;
+ }
+ }
+ }
+ inline void CubeToSphere(const Real a, const Real b, const char index,
+ Real & x, Real & y, Real & z)
+ {
+ switch( index )
+ {
+ case 0:
+ x = a;
+ y = b;
+ z = (Real) sqrt(max(0.0, 1.0 - x*x-y*y));
+ break;
+ case 1:
+ x = -a;
+ y = -b;
+ z = -(Real) sqrt(max(0.0, 1.0 - x*x-y*y));
+ break;
+ case 2:
+ z = a;
+ x = b;
+ y = (Real) sqrt(max(0.0, 1.0 - x*x-z*z));
+ break;
+ case 3:
+ z = -a;
+ x = -b;
+ y = -(Real) sqrt(max(0.0, 1.0 - x*x-z*z));
+ break;
+ case 4:
+ y = a;
+ z = b;
+ x = (Real) sqrt(max(0.0, 1.0 - y*y-z*z));
+ break;
+ case 5:
+ y = -a;
+ z = -b;
+ x = -(Real) sqrt(max(0.0, 1.0 - y*y-z*z));
+ break;
+ }
+ }
+ inline unsigned long IntToUInt(long value)
+ {
+ return (value < 0)?(unsigned long) (-1 - (2 * value)):(unsigned long) (2 * value);
+ }
+ inline long UIntToInt(unsigned long uiValue)
+ {
+ return (uiValue & 1)?-((long) ((uiValue+1) >> 1)):((long) (uiValue >> 1));
+ }
+ inline void ComputeVectorMinMax(const Real * const tab,
+ unsigned long size,
+ unsigned long dim,
+ unsigned long stride,
+ Real * minTab,
+ Real * maxTab,
+ O3DGCSC3DMCQuantizationMode quantMode)
+ {
+ if (size == 0 || dim == 0)
+ {
+ return;
+ }
+ unsigned long p = 0;
+ for(unsigned long d = 0; d < dim; ++d)
+ {
+ maxTab[d] = minTab[d] = tab[p++];
+ }
+ p = stride;
+ for(unsigned long i = 1; i < size; ++i)
+ {
+ for(unsigned long d = 0; d < dim; ++d)
+ {
+ if (maxTab[d] < tab[p+d]) maxTab[d] = tab[p+d];
+ if (minTab[d] > tab[p+d]) minTab[d] = tab[p+d];
+ }
+ p += stride;
+ }
+
+ if (quantMode == O3DGC_SC3DMC_DIAG_BB)
+ {
+ Real diag = Real( 0.0 );
+ Real r;
+ for(unsigned long d = 0; d < dim; ++d)
+ {
+ r = (maxTab[d] - minTab[d]);
+ diag += r*r;
+ }
+ diag = static_cast<Real>(sqrt(diag));
+ for(unsigned long d = 0; d < dim; ++d)
+ {
+ maxTab[d] = minTab[d] + diag;
+ }
+ }
+ else if (quantMode == O3DGC_SC3DMC_MAX_ALL_DIMS)
+ {
+ Real maxr = (maxTab[0] - minTab[0]);
+ Real r;
+ for(unsigned long d = 1; d < dim; ++d)
+ {
+ r = (maxTab[d] - minTab[d]);
+ if ( r > maxr)
+ {
+ maxr = r;
+ }
+ }
+ for(unsigned long d = 0; d < dim; ++d)
+ {
+ maxTab[d] = minTab[d] + maxr;
+ }
+ }
+ }
+}
+#endif // O3DGC_COMMON_H
+