mi32/quantizer.h

Go to the documentation of this file.

#ifndef  INC_MI32_QUANTIZER_H
#define  INC_MI32_QUANTIZER_H

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

//=====================================================================================================================

class QUANTIZER_VALUES {
   public:

      QUANTIZER_VALUES (
         ): m_ScaleQtoD(1), m_ScaleDtoQ(1), m_OffsetQtoD(0) { }

      QUANTIZER_VALUES (
         double ScaleQtoD,          
         double OffsetQtoD          
         ): m_ScaleQtoD(ScaleQtoD), m_ScaleDtoQ(1.0/ScaleQtoD), m_OffsetQtoD(OffsetQtoD) { }

      double CalcDouble (
         double ValueQ              
         ) const { return (ValueQ * m_ScaleQtoD + m_OffsetQtoD); }

      INT16 CalcPrecision () const
         {
         if (m_ScaleQtoD == 0) return (0);
         double iscale = floor(1.0 / fabs(m_ScaleQtoD) + .5);
         return (static_cast<INT16>(FAST_CEIL_NEARINT(log(iscale)/log(10.0))));
         }

      double CalcRaw (
         double ValueD              
         ) const { return ((ValueD - m_OffsetQtoD) * m_ScaleDtoQ); }

      double GetScale () const
         { return (m_ScaleQtoD); }

      double GetOffset () const
         { return (m_OffsetQtoD); }

      void Set (
         double ScaleQtoD,          
         double OffsetQtoD          
         ) { SetScale(ScaleQtoD); SetOffset(OffsetQtoD); }

      void SetScale (
         double ScaleQtoD           
         ) { m_ScaleQtoD = ScaleQtoD; m_ScaleDtoQ = 1.0 / ScaleQtoD; }

      void SetOffset (
         double OffsetQtoD          
         ) { m_OffsetQtoD = OffsetQtoD; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ScaleQtoD;
      double m_ScaleDtoQ;
      double m_OffsetQtoD;
      #endif
   };

//=====================================================================================================================

template<typename _TypeQuantized> class QUANTIZER : public QUANTIZER_VALUES {
   public:

      QUANTIZER ()
         { }

      QUANTIZER (
         double ScaleQtoD,          
         double OffsetQtoD          
         ): QUANTIZER_VALUES(ScaleQtoD,OffsetQtoD) { }

      _TypeQuantized CalcInt (
         double ValueD              
         ) const { return (static_cast<_TypeQuantized>(FAST_ROUND_EXACT(CalcRaw(ValueD)))); }

   };

//=====================================================================================================================

class QUANTIZER_LPOINT2D {
   public:

      QUANTIZER_LPOINT2D ()
         { }

      QUANTIZER_LPOINT2D (
         double ScaleX,             
         double ScaleY,             
         double OffsetX,            
         double OffsetY             
         ): m_X(ScaleX,OffsetX), m_Y(ScaleY,OffsetY)
         { }

      QUANTIZER_LPOINT2D (
         const DPOINT2D& Scale,     
         const DPOINT2D& Offset     
         ): m_X(Scale.x,Offset.x), m_Y(Scale.y,Offset.y)
         { }

      DPOINT2D CalcDouble2D (
         const LPOINT2D& ptQ        
         ) const { return (DPOINT2D(m_X.CalcDouble(ptQ.x),m_Y.CalcDouble(ptQ.y))); }

      void CalcDouble2D (
         const LPOINT2D& ptQ,       
         DPOINT2D& ptD              
         ) const { ptD.x = m_X.CalcDouble(ptQ.x); ptD.y = m_Y.CalcDouble(ptQ.y); }

      LPOINT2D CalcInt2D (
         const DPOINT2D& ptD        
         ) const { return (LPOINT2D(m_X.CalcInt(ptD.x),m_Y.CalcInt(ptD.y))); }

      void CalcInt2D (
         const DPOINT2D& ptD,       
         LPOINT2D& ptQ              
         ) const { ptQ.x = m_X.CalcInt(ptD.x); ptQ.y = m_Y.CalcInt(ptD.y); }

      void CalcRaw2D (
         const DPOINT2D& ptD,       
         DPOINT2D& ptRaw            
         ) const { ptRaw.x = m_X.CalcRaw(ptD.x); ptRaw.y = m_Y.CalcRaw(ptD.y); }

      const QUANTIZER<INT32>& GetX () const
         { return (m_X); }

      const QUANTIZER<INT32>& GetY () const
         { return (m_Y); }

      void Set2D (
         const DPOINT2D& Scale,
         const DPOINT2D& Offset
         ) { m_X.Set(Scale.x,Offset.x); m_Y.Set(Scale.y,Offset.y); }

      void SetX (
         const QUANTIZER_VALUES& QuantX
         ) { m_X.Set(QuantX.GetScale(),QuantX.GetOffset()); }

      void SetX (
         double ScaleX,             
         double OffsetX             
         ) { m_X.Set(ScaleX,OffsetX); }

      void SetY (
         const QUANTIZER_VALUES& QuantY
         ) { m_Y.Set(QuantY.GetScale(),QuantY.GetOffset()); }

      void SetY (
         double ScaleY,             
         double OffsetY             
         ) { m_Y.Set(ScaleY,OffsetY); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      QUANTIZER<INT32> m_X;
      QUANTIZER<INT32> m_Y;
      #endif
   };

//=====================================================================================================================

class QUANTIZER_LPOINT3D : public QUANTIZER_LPOINT2D {
   public:

      QUANTIZER_LPOINT3D ()
         { }

      QUANTIZER_LPOINT3D (
         double ScaleX,             
         double ScaleY,             
         double ScaleZ,             
         double OffsetX,            
         double OffsetY,            
         double OffsetZ             
         ): QUANTIZER_LPOINT2D(ScaleX,ScaleY,OffsetX,OffsetY), m_Z(ScaleZ,OffsetZ) { }

      QUANTIZER_LPOINT3D (
         const DPOINT3D& Scale,     
         const DPOINT3D& Offset     
         ): QUANTIZER_LPOINT2D(Scale,Offset), m_Z(Scale.z,Offset.z) { }

      DPOINT3D CalcDouble3D (
         const LPOINT3D& ptQ        
         ) const { return (DPOINT3D(GetX().CalcDouble(ptQ.x),GetY().CalcDouble(ptQ.y),m_Z.CalcDouble(ptQ.z))); }

      void CalcDouble3D (
         const LPOINT3D& ptQ,       
         DPOINT3D& ptD              
         ) const { ptD.x = GetX().CalcDouble(ptQ.x); ptD.y = GetY().CalcDouble(ptQ.y); ptD.z = m_Z.CalcDouble(ptQ.z); }

      LPOINT3D CalcInt3D (
         const DPOINT3D& ptD        
         ) const { return (LPOINT3D(GetX().CalcInt(ptD.x),GetY().CalcInt(ptD.y),m_Z.CalcInt(ptD.z))); }

      void CalcInt3D (
         const DPOINT3D& ptD,       
         LPOINT3D& ptQ              
         ) const { ptQ.x = GetX().CalcInt(ptD.x); ptQ.y = GetY().CalcInt(ptD.y); ptQ.z = m_Z.CalcInt(ptD.z); }

      void CalcRaw3D (
         const DPOINT3D& ptD,       
         DPOINT3D& ptRaw            
         ) const { CalcRaw2D(ptD,ptRaw); ptRaw.z = m_Z.CalcRaw(ptD.z); }

      const QUANTIZER<INT32>& GetZ () const
         { return (m_Z); }

      void Set3D (
         const DPOINT3D& Scale,
         const DPOINT3D& Offset
         ) { Set2D(Scale,Offset); m_Z.Set(Scale.z,Offset.z); }

      void SetZ (
         const QUANTIZER_VALUES& QuantZ
         ) { m_Z.Set(QuantZ.GetScale(),QuantZ.GetOffset()); }

      void SetZ (
         double ScaleZ,             
         double OffsetZ             
         ) { m_Z.Set(ScaleZ,OffsetZ); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      QUANTIZER<INT32> m_Z;
      #endif
   };

//=====================================================================================================================

#endif   // INC_MI32_QUANTIZER_H

---