PbDataMapping.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-2014 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
#ifndef  _PB_DATA_MAPPING_
#define  _PB_DATA_MAPPING_
 
#include <MeshViz/graph/PbBase.h>
 
#include <Inventor/SbColor.h>

class  PbDataMapping : public PbBase {
 
 public:
 
  typedef float PbHLSColor[3] ;
 
 

  PbDataMapping() ;

  ~PbDataMapping() ;

  PbDataMapping(const PbDataMapping  &dataMapping) ;

  PbDataMapping& operator=(const PbDataMapping &dataMapping) ;

  const SbColor *getRGBColor(float value) const;

  const float   *getHLSColor(float value) const;

  const SbColor *getRGBColor(float value, float &transparency) const;

  const float   *getHLSColor(float value, float &transparency) const;
 
  

  void setMinThreshold(float threshold_min) ;

  void setMinThreshold(float threshold_min, const SbColor &cmin, float transp_min=0.0) ;

  void setMinThreshold(float threshold_min, PbHLSColor cmin, float transp_min=0.0) ;

  void setMaxThreshold(float threshold_max) ;

  void setMaxThreshold(float threshold_max, const SbColor &cmax, float transp_max=0.0) ;

  void setMaxThreshold(float threshold_max, PbHLSColor cmax, float transp_max=0.0) ;

  const SbColor* getMinRGBThreshold(float &threshold_min) const ;

  const float*   getMinHLSThreshold(float &threshold_min) const ;

  const SbColor* getMinRGBThreshold(float &threshold_min, float &transp_min) const ;

  const float*   getMinHLSThreshold(float &threshold_min, float &transp_min) const ;

  const SbColor* getMaxRGBThreshold(float &threshold_max) const ;

  const float*   getMaxHLSThreshold(float &threshold_max) const ;

  const SbColor* getMaxRGBThreshold(float &threshold_max, float &transp_max) const ;

  const float*   getMaxHLSThreshold(float &threshold_max, float &transp_max) const ;

  void enableThresholds(SbBool min, SbBool max) ;

  void thresholdsEnabled(SbBool &min, SbBool &max) const
    { min = m_minEnabled ; max = m_maxEnabled ;}

  void enableTransparency(SbBool flag);

  SbBool isTransparencyEnabled() const
    { return m_transparencyEnabled ; }

  void setTransparencyValueDeletedParts(float value);

  float getTransparencyValueDeletedParts() const; 
 
  /*---------------------------------------------------------------------------*/
 
 
 private:
  // Data mapping type
  enum ClassType {
    DATA_MAPPING,
    LINEAR_DATA_MAPPING,
    NON_LINEAR_DATA_MAPPING1,
    NON_LINEAR_DATA_MAPPING2
  } ;
 
  virtual ClassType getClassType() const 
    { return DATA_MAPPING ; }
 
  uint32_t getId() const { return m_uniqueId; }
 
 private:
  // Notify a change to all connected objects 
  void notifyChange();
  
  // Compute a color interpolation 
  // Interpolation between (c1, v1) and (c2, v2) for a vi value
  // vi is updated.
  static void  colorInterpolation(const SbColor &c1, float v1, 
                                  const SbColor &c2, float v2, 
                                  float vi, SbColor *ci) ;
  static void  colorInterpolation(const SbColor &c1, float t1, float v1, 
                                  const SbColor &c2, float t2, float v2, 
                                  float vi, SbColor *ci, float &ti) ;
  static void transparencyInterpolation(float t1, float v1, 
                                        float t2, float v2, 
                                        float vi, float ti) ;
 
  float   m_transparencyValueDeletedParts;
  SbColor *m_colorValue ;
  virtual const SbColor* computeColor(float value) const=0;
  virtual const SbColor* computeColor(float value, float &transparency) const=0;
  SbBool  m_transparencyEnabled;
 
  // Unique id for this node.
  uint32_t    m_uniqueId;
 
 private:
  static  uint32_t sm_nextUniqueId;
 
  // Used by constructor per copy and affectation operator
  void copy(const PbDataMapping &dataMapping, SbBool isConstructorPerCopy) ;
 
  float   m_thresholdMin, m_thresholdMax, m_transparencyMin, m_transparencyMax;
  SbColor m_colorMin, m_colorMax ;
  SbBool  m_minEnabled, m_maxEnabled, m_isMinColor, m_isMaxColor;
} ;
 
/*----------------------------------------------------------------------------*/
 
#endif /* _PB_DATA_MAPPING_ */