#pragma once

/*----------------------------------------------------------\
                    Includes
\----------------------------------------------------------*/
#include <string>
#include <cmath>
#include <assert.h>
#include "vector.h"

#define DICOM_SCALE_NAME "DICOM"

/*----------------------------------------------------------\
                    Classes
\----------------------------------------------------------*/
class CScale
{
public:

   double   m_dblVer,     // distance verticale   pour 1 pixel
            m_dblHor;     // distance horizontale pour 1 pixel
   std::string  m_strName;    // nom de l'échelle

   CScale(std::string pszName, double dblHor = 0.0, double dblVer = 0.0, bool fOrthonorme = true);

   inline bool operator != (const CScale &sce) { return (!(*this == sce)); };
   inline bool operator == (const CScale &sce)
   {
      return (   (m_fVerOK       == sce.m_fVerOK)
              && (m_fHorOK       == sce.m_fHorOK)
              && (m_fOrthonorme  == sce.m_fOrthonorme)
              && (m_dblVer       == sce.m_dblVer)
              && (m_dblHor       == sce.m_dblHor)
              && (m_isDicom      == sce.m_isDicom )
             );
   }
   void    Update             (double dblHor, double dblVer);
   void    SetScaleLire       (double, double);
   void    SetScale           (double, double);
   void    SetScale           (double, const CVector &);
   void    SetVerticalScale   (double, const CVector &);
   void    SetHorizontalScale (double, const CVector &);
   double  Surface            (Rect &rc)                   const { return (Surface (rc.Width (), rc.Height ()));    }
   double  Surface            (double dblX, double dblY)          const;
   double  Surface            (double dblSurface)                 const;
   double  Distance           (const Point&, const Point&)      const;
   bool    Valid              (void)                              const { return (m_fVerOK || m_fHorOK);                 };
   bool    IsDicom            (void)                              const { return m_isDicom; }
   // les membres m_dblXXX sont initialisés à 0, donc si le calibrage n'est pas défini
   // ces fonctions retournent 0
   double  DistanceX          (long   lDistance)              const { assert (m_fHorOK);
                                                                      return (abs (lDistance)    * m_dblHor); };
   double  DistanceY          (long   lDistance)              const { assert (m_fVerOK);
                                                                      return (abs (lDistance)    * m_dblVer); };
   double  DistanceX          (int  dwDistance)               const { assert (m_fHorOK);
                                                                      return (dwDistance         * m_dblHor); };
   double  DistanceY          (int  dwDistance)               const { assert (m_fVerOK);
                                                                      return (dwDistance         * m_dblVer); };
   double  Distance           (double dblDistance)            const { assert (Valid () && (m_dblHor == m_dblVer) && (dblDistance >= 0.));
                                                                      return (fabs (dblDistance) * m_dblHor); };
   double  DistanceX          (double dblDistance)            const { assert (m_fHorOK);
                                                                      return (fabs (dblDistance) * m_dblHor); };
   double  DistanceY          (double dblDistance)            const { assert (m_fVerOK);
                                                                      return (fabs (dblDistance) * m_dblVer); };

  protected:
    bool    m_fVerOK,     // calibration verticale effectuée
            m_fHorOK,     // calibration horizontale effectuée
            m_fOrthonorme,// calbiration horizontale = calibration verticale
            m_isDicom;
};

/*----------------------------------------------------------\
                    Variables globales
\----------------------------------------------------------*/
extern const CScale *g_pCurrentScale;