SoVolumeHistogram.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : T.DUFOUR (May 2004)
**=======================================================================*/
 
#ifndef  _SO_VOLUME_HISTOGRAM_
#define  _SO_VOLUME_HISTOGRAM_
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#pragma warning(disable:4127)
#endif
 
#include <Inventor/SbDataType.h>
#include <Inventor/SbLinear.h>
#include <Inventor/helpers/SbDataTypeMacros.h>
 
#include <Inventor/STL/limits>
#include <Inventor/STL/vector>
 
class SoBufferObject;
class SoArithmetic;
 
class  SoVolumeHistogram
{
public:
  SoVolumeHistogram(const SbDataType &dataType);
 
  ~SoVolumeHistogram();
 
  void setInputValueRange( double rangeMin, double rangeMax );
 
  void setUndefinedValue( const double undefinedValue)
  { m_undefinedValue=undefinedValue; }
 
  double getUndefinedValue() const
  { return m_undefinedValue; };
 
  size_t getHistoSize() const;
 
  int64_t* getHistogram();
 
  int64_t getNumValues(size_t entry);
 
  int64_t getValue(size_t entry);
 
  double getValueD(size_t entry);
 
  int64_t getMinValue() const;
 
  int64_t getMaxValue() const;
 
  double getMinValueD() const;
 
  double getMaxValueD() const;
 
  double getMax() const;
 
  double getMin() const;
 
  int getNumSignificantBits() const;
 
  inline void addValues(SoBufferObject* values, const int numValues);
 
  inline void addValues(SoBufferObject* values, const SbVec3i32& arrayDim);
 
  void addValues(SoBufferObject* values, const SbVec3i32& arrayDim, const SbBox3i32& range);
 
  void set(const std::vector<int64_t> & histo);
 
  void set(const std::vector<int64_t>& histo, const std::vector<double>& values);
 
  template<typename T> inline size_t getEntry(T value) const;
 
  static void computeMinMax(
    SoBufferObject* valuesBuffer,
    const SbDataType& dataType,
    const SbVec3i32& arrayDim,
    const SbBox3i32& range,
    double& min,
    double& max
    );
 
  static void computeMinMaxWithUndefined(
    SoBufferObject* valuesBuffer,
    const double undefinedValue,
    const SbDataType& dataType,
    const SbVec3i32& arrayDim,
    const SbBox3i32& range,
    double& min,
    double& max
    );
 
  static void computeMinMax(
    void* valuesBuffer,
    const SbDataType& dataType,
    const SbVec3i32& arrayDim,
    SbVec2d& minMax);
 
  static void computeMinMaxWithUndefined(
    void* valuesBuffer,
    const double undefinedValue,
    const SbDataType& dataType,
    const SbVec3i32& arrayDim,
    SbVec2d& minMax
    );
 
private:
  static void initClass();
  static void exitClass();
 
private:
  template<typename T> inline size_t getEntryInternal(T value) const;
 
  template<typename T> inline size_t getEntryCaster(T value) const;
 
  unsigned int computeNumSignificantBits() const;
 
  std::vector<int64_t> m_histo;  // histogram
  int64_t  m_valueMin;           // min integer value of the dataset for integer data types
  int64_t  m_valueMax;           // max integer value of the dataset for integer data types
  double   m_valueMinD;          // min integer value of the dataset for floating data types
  double   m_valueMaxD;          // max integer value of the dataset for floating data types
  unsigned int m_numSignificantBits; // number of significant bits, only relevant for integer data types
 
  SbDataType m_dataType;     // data type
  double m_rangeMin;         // for floating data type.
  double m_rangeMax;         // for floating data type.
  double m_undefinedValue;   // undefined Value.
 
  // makeStats template
  template <typename T>
  void makeStat(
    const void* values,
    const SbVec3i32& arrayDim,
    const SbBox3i32& range
    );
 
  static SoArithmetic* s_arithmeticInterface;
};
 
/*******************************************************************************/
void
SoVolumeHistogram::addValues(SoBufferObject* values, const int numValues)
{
  addValues(values, SbVec3i32(numValues, 1, 1), SbBox3i32(SbVec3i32(0, 0, 0), SbVec3i32(numValues, 1, 1)));
}
 
/*******************************************************************************/
void SoVolumeHistogram::addValues(SoBufferObject* values, const SbVec3i32& arrayDim)
{
  addValues(values, arrayDim, SbBox3i32(SbVec3i32(0,0,0),arrayDim));
}
 
/*******************************************************************************/
template<typename T> size_t
SoVolumeHistogram::getEntryInternal(T value) const
{
  assert(m_dataType.isInteger());
  assert(sizeof(T) <= 4);
  size_t offset = 0;
  size_t factor = 1;
 
  if ( std::numeric_limits<T>::is_signed )
    offset = (sizeof(T) >= 2) ? 0x8000 : 0x80;
 
  if ( sizeof(T) == 4 )
    factor = (size_t)0x10000;
 
  size_t entry = (size_t)(value/int64_t(factor)+int64_t(offset));
 
  return entry;
}
 
/*******************************************************************************/
template<typename T> size_t
SoVolumeHistogram::getEntryCaster(T value) const
{
  return getEntryInternal(T(value));
}
 
/*******************************************************************************/
template<typename T> size_t
SoVolumeHistogram::getEntry(T value) const
{
  size_t ret = 0;
 
  switch (m_dataType)
  {
  case SbDataType::UNSIGNED_SHORT:
    ret = getEntryInternal<unsigned short>((unsigned short)value);
    break;
  case SbDataType::UNSIGNED_INT32:
    ret = getEntryInternal<uint32_t>((uint32_t)value);
    break;
  case SbDataType::SIGNED_BYTE:
    ret = getEntryInternal<signed char>((signed char)value);
    break;
  case SbDataType::SIGNED_SHORT:
    ret = getEntryInternal<signed short>((signed short)value);
    break;
  case SbDataType::SIGNED_INT32:
    ret = getEntryInternal<int32_t>((int32_t)value);
    break;
  case SbDataType::FLOAT:
    ret = getEntryInternal<float>((float)value);
    break;
  case SbDataType::UNSIGNED_BYTE:
    ret = getEntryInternal<unsigned char>((unsigned char)value);
    break;
  case SbDataType::DOUBLE:
    ret = getEntryInternal<double>((double)value);
    break;
  default:
    assert(0);
    break;
  }
 
  return ret;
}
 
/*******************************************************************************/
template<> inline size_t
SoVolumeHistogram::getEntryInternal<float>(float value) const
{
  assert(m_dataType == SbDataType::FLOAT);
  if ( m_rangeMax == m_rangeMin )
    return 0;
  double factorDouble = 0.0f;
  factorDouble = 0xffff / (m_rangeMax - m_rangeMin);
  size_t entry = (size_t)((value-m_rangeMin)*factorDouble);
 
  return SbMathHelper::Clamp(entry, (size_t)0, (size_t)0xffff);
}
 
/*******************************************************************************/
template<> inline size_t
SoVolumeHistogram::getEntryInternal<double>(double value) const
{
  assert(m_dataType == SbDataType::DOUBLE);
  if ( m_rangeMax == m_rangeMin )
    return 0;
  double factorDouble = 0.0f;
  factorDouble = 0xffff / (m_rangeMax - m_rangeMin);
  size_t entry = (size_t)((value-m_rangeMin)*factorDouble);
 
  return SbMathHelper::Clamp(entry, (size_t)0, (size_t)0xffff);
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif /* _SO_VOLUME_HISTOGRAM_ */