MAth-Cloud-3.0.0/api.ipsocloud.com/math-imt/imt/scale.cpp

/*******************************************************************\

    Fichier     : Scale.cpp

    Date        : 28/04/98
    Version     : 1.005

    Description : Gestion de l'échelle pixel <-> mètres

|*******************************************************************|
Bugs:
Notes:
   m_dblHor et m_dblVer sont des membres publiques uniquement pour
   la sauvegarde et le rechargement depuis la base de registre.
   A améliorer...
|*******************************************************************|
Historique :
   28/04/98 1.005 : Différentes fonctions de mesure ajoutées
   27/06/97 1.000 : Première version
\*******************************************************************/
/*----------------------------------------------------------\
                        Includes
\----------------------------------------------------------*/
#include "scale.h"

CScale::CScale (std::string pszName, double dblHor, double dblVer, bool fOrthonorme) 
      : m_strName (pszName), 
        m_isDicom( false )
{
	if (m_strName.length () == 0)
		m_strName = "Default";//  [JAK - 17/6/2002]
	m_fOrthonorme = fOrthonorme;
	if ( !m_strName.compare( DICOM_SCALE_NAME ) )
		m_isDicom = true;
	Update (dblHor, dblVer);
} // end of CScale

void CScale::Update (double dblHor, double dblVer)
{
	m_dblHor = dblHor;
	m_dblVer = dblVer;
	m_fVerOK = (m_dblVer != 0.0);
	m_fHorOK = (m_dblHor != 0.0);
} // end of SetHorizontalScale

//void CScale::Load (CRegister &reg)
//{
//   Update (reg.GetDouble ("Horizontal"), reg.GetDouble ("Vertical"));
//} // fin de Load

//void CScale::Save (CRegister &reg)
//{
//	m_dblHor =	m_dblHor * 1000000;
//	m_dblHor =	floor(m_dblHor);
//	m_dblHor =  m_dblHor/1000000;
//
//	m_dblVer =	m_dblVer * 1000000;
//	m_dblVer =	floor(m_dblVer);
//	m_dblVer =  m_dblVer/1000000;

//	reg.SetDouble ("Horizontal", m_dblHor);
//	reg.SetDouble ("Vertical",   m_dblVer);
//} // fin de Save

/*----------------------------------------------------------\
|                       SetxxxScale                         |
|-----------------------------------------------------------|
| DESCRIPTION :                                             |
|  Détermine les échelles horizontales et verticales        |
|-----------------------------------------------------------|
| PARAMETRES  :                                             |
|  dblReal : taille réelle de la distance mesurée           |
|  vScale  : vecteur servant à la définition de l'echelle   |
\----------------------------------------------------------*/
void CScale::SetScale (double dblReal, const CVector &vScale)
{
	SetScale (dblReal, vScale.Norm ());
} // fin de SetScale

void CScale::SetScale (double dblReal, double dblNorm)
{
	double dblEchelle;
	assert (m_fOrthonorme);
	if (dblNorm)
	{
		dblEchelle = dblReal / fabs (dblNorm);
	
		dblEchelle = dblEchelle * 1000000; //recherche de la précision exp -6
		dblEchelle = floor(dblEchelle);
		dblEchelle = dblEchelle/1000000;

		m_dblHor = m_dblVer = dblEchelle;

		m_fVerOK =
		m_fHorOK = true;
	}
} // fin de SetScale


void CScale::SetScaleLire (double dblEchelle, double i)
{
	assert (m_fOrthonorme);
	
	dblEchelle = dblEchelle * 1000000;
	dblEchelle = floor(dblEchelle);
	dblEchelle = dblEchelle/1000000;
	
	i = i / 1000000;
	dblEchelle = dblEchelle + i;
	m_dblVer = dblEchelle;// - reste;
	m_dblHor = m_dblVer;

	m_fVerOK =	m_fHorOK = true;
} // fin de SetScaleLire

void CScale::SetHorizontalScale (double dblReal, const CVector &vScale)
{
	assert (vScale.StartPoint ().y == vScale.EndPoint ().y);

	if (vScale.Norm ())
	{
		m_dblHor = dblReal / fabs (vScale.Norm ());
		m_fHorOK = (m_dblHor != 0.0);
		if (m_fOrthonorme)
		{
			m_dblVer = m_dblHor;
			m_fVerOK = m_fHorOK;
		}
	}
} // end of SetHorizontalScale

void CScale::SetVerticalScale (double dblReal, const CVector &vScale)
{
	assert (vScale.StartPoint ().x == vScale.EndPoint ().x);
	if (vScale.Norm ())
	{
		m_dblVer = dblReal / fabs (vScale.Norm ());
		m_fVerOK = (m_dblVer != 0.0);
		if (m_fOrthonorme)
		{
			m_dblHor = m_dblVer;
			m_fHorOK = m_fVerOK;
		}
	}
} // end of SetVerticalScale

double CScale::Surface (double dblX, double dblY) const
{
	// si l'une des direction n'est pas calibrée, on utilise
	// les valeurs de l'autre direction
	if (m_fHorOK)  dblX = DistanceX (dblX);
	else           dblX = DistanceY (dblX);
	if (m_fVerOK)  dblY = DistanceY (dblY);
	else           dblY = DistanceX (dblY);

	return (dblX * dblY);
} // fin de Surface

double CScale::Surface (double dblSurface) const
{
	assert (Valid ());
	// si l'une des direction n'est pas calibrée, on utilise
	// les valeurs de l'autre direction
	if (m_fHorOK)
	{
		if (m_fVerOK)
			return (dblSurface * m_dblVer * m_dblHor);
		else
			return (dblSurface * m_dblHor * m_dblHor);
	}
	else
		return (dblSurface * m_dblVer * m_dblVer);
} // fin de Surface

double CScale::Distance (const Point &pt1, const Point &pt2) const
{
	double dblX, dblY;

	// si l'une des direction n'est pas calibrée, on utilise
	// les valeurs de l'autre direction
	if (m_fHorOK)  dblX = DistanceX (pt2.x - pt1.x);
	else           dblX = DistanceY (pt2.x - pt1.x);
	if (m_fVerOK)  dblY = DistanceY (pt2.y - pt1.y);
	else           dblY = DistanceX (pt2.y - pt1.y);

	return (sqrt (dblX * dblX + dblY * dblY));
} // fin de Distance