remove backup dir and old site configuration files

api.ipsocloud.com/math.backup/.gitignore

@@ -1,73 +0,0 @@
-# This file is used to ignore files which are generated
-# ----------------------------------------------------------------------------
-
-*~
-*.autosave
-*.a
-*.core
-*.moc
-*.o
-*.obj
-*.orig
-*.rej
-*.so
-*.so.*
-*_pch.h.cpp
-*_resource.rc
-*.qm
-.#*
-*.*#
-core
-!core/
-tags
-.DS_Store
-.directory
-*.debug
-Makefile*
-*.prl
-*.app
-moc_*.cpp
-ui_*.h
-qrc_*.cpp
-Thumbs.db
-*.res
-*.rc
-/.qmake.cache
-/.qmake.stash
-
-# qtcreator generated files
-*.pro.user*
-
-# xemacs temporary files
-*.flc
-
-# Vim temporary files
-.*.swp
-
-# Visual Studio generated files
-*.ib_pdb_index
-*.idb
-*.ilk
-*.pdb
-*.sln
-*.suo
-*.vcproj
-*vcproj.*.*.user
-*.ncb
-*.sdf
-*.opensdf
-*.vcxproj
-*vcxproj.*
-
-# MinGW generated files
-*.Debug
-*.Release
-
-# Python byte code
-*.pyc
-
-# Binaries
-# --------
-*.dll
-*.exe
-

api.ipsocloud.com/math.backup/imt/CEIMInfo.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "point.h"
-#include "vector.h"
-
-struct sSlope
-{
-  long m_dwPos[2];    // position du debut et de la fin de la pente
-  long m_dwMiddle;    // position du point m_ptMiddle
-  long m_dwIntensity; // intensite du point mediant (Le 'vrai')
-  Point m_ptMiddle;   // point milieu de la pente ou juste avant
-  Point m_ptDraw;     // le point a afficher (le + proche de la valeur mediane)
-  double m_dblMiddle; // distance entre les points encadrants le milieu
-};
-
-struct sParoi
-{
-  sSlope  m_slope[3]; // definitions des trois pentes caracteristiques du profil de la paroi
-  CVector m_vMeasure; // vecteur sur lequel la detection a ete effectuee
-};
-
-class CEIMInfo
-{
-  public:
-  
-    // validite de la mesure
-    bool m_fValid; // prendre cette information en compte pour la mesure et l'affichage
-		    
-    // car le profil a ete detecte									        	   
-    bool m_fThrownOut; // rejete car ne repondant pas a un des critere d'uniformite (pour verif)
-    													        	   
-    // pour mesure (normes sans mises a l'echelle)
-    double m_dblDist; // distance de m_ptMiddle1 [0] a son projete orthogonal sur m_vUser
-    													        	   
-    // cette distance doit etre constante pour tous les points, sinon le vecteur			        	   
-    // m_vUser n'est pas parallere a la paroi (ou la detection est incorrecte)				        	   
-    double m_dblQI;											        	   
-    double m_dblEIM; // distance de m_ptMiddle1 [0] a m_ptMiddle2 [0]					        	   
-    double m_dblINT; // distance de m_ptMiddle1 [0] a m_ptMiddle3 [0]					        	   
-    double m_dblDia; // distance de m_ptMiddle2 [1] a son projete orthogonal sur m_vUser
-    													        	   
-    double m_dblEIMd; // moyenne des insentises de m_ptMiddle1[0] a m_ptMiddle2[0]	        	   
-    double m_dblINTd; // moyenne des intensites de m_ptMiddle1[0] a m_ptMiddle3[0]	        	   
-    double m_dblMEDd; // moyenne des intensites de m_ptMiddle2[0] a m_ptMiddle3[0]
-    													        	   
-    int m_diagnostic; 
-    													        	   
-    // Pour mesures intermediaires (detection du profil)						        	   
-    struct sParoi m_Paroi[2]; // 0 : profil bas ou droite. 1 : profil haut ou gauche (pour diametre)
-};
-

api.ipsocloud.com/math.backup/imt/CEIMResult.cpp

@@ -1,159 +0,0 @@
-#include "CEIMResult.h"
-
-#include <cstdlib>
-
-
-CEIMResult::CEIMResult()
-{
-  result = new imt::IMTResult;
-  Initialize();
-}
-
-CEIMResult::~CEIMResult()
-{
-  if ( result->vect_intima )
-  {
-    delete[] result->vect_intima;
-  }
-
-  if ( result->vect_media )
-  {
-    delete[] result->vect_media;
-  }
-
-  if ( result->vect_adventitia )
-  {
-    delete[] result->vect_adventitia;
-  }
-
-  delete result;
-}
-
-void CEIMResult::Initialize()
-{
-  result->imt_max = 0.0;
-  result->imt_mean = 0.0;
-  result->imt_standardDeviation = 0.0;
-  result->intima_mean = 0.0;
-  result->media_mean = 0.0;
-  result->qualityIndex = 0.0;
-  result->distance = 0.0;
-  result->numberOfPoints = 0;
-  result->vect_intima = NULL;
-  result->vect_media = NULL;
-  result->vect_adventitia = NULL;
-}
-
-bool CEIMResult::fill( imt::IMTResult* res )
-{
-  if ( res )
-  {
-    if ( res->vect_adventitia )
-    {
-      delete[] res->vect_adventitia;
-    }
-    
-    if ( res->vect_media )
-    {
-      delete[] res->vect_media;
-    }
-    
-    if ( res->vect_intima )
-    {
-      delete[] res->vect_intima;
-    }
-    
-    int n = result->numberOfPoints;
-    res->imt_max = result->imt_max;
-    res->imt_mean = result->imt_mean;
-    res->imt_standardDeviation = result->imt_standardDeviation;
-    res->intima_mean = result->intima_mean;
-    res->media_mean = result->media_mean;
-    res->qualityIndex = result->qualityIndex;
-    res->distance = result->distance;
-    res->numberOfPoints = n;
-    res->p0 = result->p0;
-    res->p1 = result->p1;
-    
-    res->vect_intima = new imt::Point[ n ];
-	
-    if ( !res->vect_intima )
-    {
-      return false;
-    }
-    
-    res->vect_media = new imt::Point[ n ];
-
-    if ( !res->vect_media )
-    {
-      delete[] res->vect_intima;
-      res->vect_intima = NULL;
-      
-      return false;
-    }
-    
-    res->vect_adventitia = new imt::Point[ n ];
-
-    if ( !res->vect_adventitia )
-    {
-      delete[] res->vect_intima;
-      res->vect_intima = NULL;
-      delete[] res->vect_media;
-      res->vect_media = NULL;
-      
-      return false;
-    }
-
-    int i;
-    for ( i = 0; i < n; i++ )
-    {
-      res->vect_adventitia[ i ] = result->vect_adventitia[ i ];
-      res->vect_media[ i ] = result->vect_media[ i ];
-      res->vect_intima[ i ] = result->vect_intima[ i ];
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-bool CEIMResult::allocate_vectors( long n_points )
-{
-  if ( !n_points )
-  {
-    return false;
-  }
-  
-  result->numberOfPoints = n_points;
-  result->vect_intima = new imt::Point[ n_points ];
-  
-  if ( !result->vect_intima )
-  {
-    return false;
-  }
-  
-  result->vect_media = new imt::Point[ n_points ];
-  
-  if ( !result->vect_media )
-  {
-    delete[] result->vect_intima;
-    result->vect_intima = NULL;
-    
-    return false;
-  }
-  
-  result->vect_adventitia = new imt::Point[ n_points ];
-  
-  if ( !result->vect_adventitia )
-  {
-    delete[] result->vect_intima;
-    result->vect_intima = NULL;
-    delete[] result->vect_media;
-    result->vect_media = NULL;
-    
-    return false;
-  }
-
-  return true;
-}

api.ipsocloud.com/math.backup/imt/CEIMResult.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "EIMResult.h"
-
-
-class CEIMResult
-{
-
-  public:
-
-    CEIMResult();
-    virtual ~CEIMResult();
-  
-    bool allocate_vectors( long n_points );
-    bool fill( imt::IMTResult* res );
-
-    imt::IMTResult* result;
-
-  private:
-  
-    void Initialize();
-};
-

api.ipsocloud.com/math.backup/imt/EIMBase.cpp

@@ -1,2610 +0,0 @@
-/*******************************************************************\
-   Fichier     : EIMBase.cpp
-   Date        : 29/04/98 
-   Version     : 1.024
-   Auteur	   : P-J Touboul
-   Description : Fonctions de d�tection et mesures de parois
-|*******************************************************************|
-Bugs:
-   Il serait plus propre dans la fonction EIM, d'appliquer le masque
-      sur le vecteur (proc�dure Mask mise en commentaire).
-Notes:
-|*******************************************************************|
-Historique :
-   29/04/98 1.024 : Modification du sens de la mesure en fonction de la position relative
-                     des points du segment utilisateur
-                    M�morisation de la distance de la mesure
-   02/04/98 1.022 : Utilisation d'une valeur minimale permettant de consid�rer qu'il
-                     y a une variation de densit� (STEP)
-                    Bug quand il y a avait UN SEUL lissage effectu�
-   11/03/98 1.020 : Nouvel algorithme possible pour la mesure de diam�tre (sym�trie)
-   31/01/98 1.010 : Mesures 'sub-pixels' permettant de gagner jusqu'� un pixel
-                    en pr�cision (1/2 pixel avant + 1/2 pixel apr�s). Les points
-                    au milieu des pentes ont donc defs coordonn�es d�cimales
-                    Correction d'un probl�me sur la d�tection de plateaux
-   22/01/98 1.001 : Correction sur le calcul des points m�dians
-                    Ajout de la position des points m�dians
-   17/03/97 1.000 : Premi�re version
-\*******************************************************************/
-/*----------------------------------------------------------\
-                    Includes
-\----------------------------------------------------------*/
-
-#include "EIMBase.h"
-#include "MeanEstimate.h"
-#include "CEIMResult.h"
-#include "EIMResult.h"
-#include "Ressource.h"
-#include "point.h"
-#include "ToolsMath.h"
-//#include "../Container/ExtendedImage.h"
-#include <limits>
-#include <string.h>
-
-#include <QImage>
-
-//#define TEST_FOR_FANTOME
-
-/*----------------------------------------------------------\
-                    Defines
-\----------------------------------------------------------*/
-#define STEP 0
-
-/*----------------------------------------------------------\
-                    Variables locales
-\----------------------------------------------------------*/
-//static char Version[] = "$VER: " __FILE__ " 1.024 (" __DATE__ ")";
-
-/*----------------------------------------------------------\
-|                      Delta                                |
-\----------------------------------------------------------*/
-char CEIMBase::Delta (unsigned char b1, unsigned char b2)
-{
-	int i;
-
-	// En utilisant STEP, on consid�re par exemple que 15/16/17 repr�sentent
-	// la m�me valeur et que ce n'est donc pas une croissance
-	i = b1 - b2;
-	if (i >  STEP)  return ( 1);
-	else if (i < -STEP)  return (-1);
-	else                 return ( 0);
-} // end of Delta
-
-/*----------------------------------------------------------\
-|                  CEIM::CEIM                               |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Constructeur de la classe                                |
-|-----------------------------------------------------------|
-| PARAMETRES  :                                             |
-|  scale : �chelle � utiliser pour les mesures              |
-\----------------------------------------------------------*/
-CEIMBase::CEIMBase (void)
-{
-	//debugOutput = NULL;
-	m_pMeasures    = NULL;
-	m_bDelta1      = 30; // variation minimale pour la premi�re pente
-	m_bDelta2      = 10; // variation minimale entre le sommet des deux pentes  // A voir Release
-	m_bSeuil1		= 140;
-
-	m_algoDiameter = algoProfile;  // algorithme par d�faut
-	m_arVariance.clear();
-	m_arVarianceAA.clear();
-	m_arVarianceII.clear();
-	m_arVarianceINT.clear();
-
-	Release();    // apr�s m_pMeasures = NULL;
-
-	m_coeff_a = -1.0; 
-	m_coeff_b = -1.0; 
-	m_coeff_c = -1.0; 
-	m_bDisplay = false; 	
-	m_parallelismeDiametre = false; // Exp�rimental
-	m_image = NULL;
-
-	m_versionTomtecAout08 = true; 
-
-} // fin de CEIM
-
-CEIMBase::~CEIMBase(void)
-{
-	Release();
-} // fin de ~CEIM
-
-void CEIMBase::SetEimAssisted(bool valide)
-{
-	m_Assist = valide;
-}
-
-bool CEIMBase::GetEimAssisted()
-{
-	return m_Assist;
-}
-
-// Calcul automatique de l'EIM
-// Ancienne version : n'est plus utilis�e 
-int CEIMBase::CalculEimAutomatique(int mode, bool bActionDiametre, Point *ptClick0, Point *ptClick1, Point *ptLastClick, unsigned char *bClicks, QImage *img,bool *fBackToNone)
-{
-	m_image = img;
-	return CalculEimAutomatique( mode, bActionDiametre, ptClick0, ptClick1, ptLastClick, bClicks, fBackToNone );
-}
-
-int CEIMBase::CalculEimAutomatique(int mode, bool bActionDiametre, Point *ptClick0, Point *ptClick1, Point *ptLastClick, unsigned char *bClicks, bool *fBackToNone)
-{
-	int retour = 0;
- 
-	if (m_Assist) 
-	{
-		if (mode == 0) 
-		{
-			Measure(*ptClick0, *ptLastClick, bActionDiametre);
-		}
-
-		double dDirection = Direction();
-		if (dDirection == 0)
-		{
-			//CMessage::Warn(MyLoadString(IDS_EIM_FAILED));
-			*fBackToNone = false;
-			return 0;
-		}
-		else
-		{
-			Point CorrectPoint = *ptLastClick;
-			CorrectPoint.y = ptClick0->y + ((long) (dDirection*(CorrectPoint.x - ptClick0->x)));
-
-			*ptClick1 = CorrectPoint;
-			*bClicks = 1;
-			retour = 1;	// Pour lancer un Invalidate 
-				
-			if (mode == 1) 
-			{
-				Measure(*ptClick0, CorrectPoint, bActionDiametre);
-			}
-
-			*ptLastClick = CorrectPoint;
-		}
-	}
- 
-	return retour; 
-}
-
-bool CEIMBase::PointInBuffer(const Point& pt)
-{
-	assert( m_image );
-
-    int dx = m_image->width();
-    int dy = m_image->height();
-
-	return ( pt.x >= 0 && pt.y >= 0 && pt.x < dx && pt.y < dy );
-}
-
-unsigned char CEIMBase::GetIntensity(const Point& pt)
-{
-	assert( m_image );
-    return qGray(m_image->pixel( pt.x, pt.y ));
-}
-
-/*----------------------------------------------------------\
-|                       Release                             |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Lib�re les ressources allou�es pour une mesure           |
-\----------------------------------------------------------*/
-void CEIMBase::Release (void)
-{
-	m_dblEIMMin		=
-	m_dblEIMMean	=
-	m_dblEIMMax		=
-	m_dblINTMin		=
-	m_dblINTMean	=
-	m_dblINTMax		=
-	m_dblDiaAAMin	=
-	m_dblDiaAAMean	=
-	m_dblDiaAAMax	=
-	m_dblDiaIIMin	=
-	m_dblDiaIIMean	=
-	m_dblDiaIIMax	=
-	m_dblQI		    =
-	m_dblQIMean	    =
-	m_dblIA		    =
-	m_dblEIMdMean	=
-	m_dblINTdMean	=
-	m_dblMEDdMean	=
-	m_dblIAd	    =
-	m_dblVariance	=
-	m_dblDistance	= 0.0;
-	m_dwPoints	    =		// nombre de points sur lesquels une mesure a �t� effectu�e
-	m_dwValidPoints	=		// nombre de points sur lesquels le profil a �t� reconnu
-	m_uErrorID	    = 0;	// ID de la cha�ne d�crivant l'erreur
-
-	if (m_pMeasures)
-	{
-		delete [] m_pMeasures;
-		m_pMeasures = NULL;
-	}
-
-	m_StartPoint.x	= -1; 
-	m_StartPoint.y	= -1; 
-	m_EndPoint.x	= -1; 
-	m_EndPoint.x	= -1; 
-
-	memset( m_bBuffer, 0, THICKNESS );
-	memset( m_cOffsets, 0, THICKNESS );
-} // fin de Release
-
-/*----------------------------------------------------------\
-|                       Measure                             |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Mesure d'une �paisseur de paroi ou d'un diam�tre         |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  gfx        : image en niveau de gris d'o� lire les       |
-|               donn�es                                     |
-|  pGraphMean : graphe dans lequel ajout� les mesures si    |
-|               non nul                                     |
-|  pt1        : premier point du segment d�terminant la     |
-|               ligne de la paroi                           |
-|  pt2        : deuxi�me point du segment                   |
-|  fDiameter  : mesure d'un diam�re ou d'une paroi          |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  VRAI si au moins une mesure a �t� effectu�e              |
-\----------------------------------------------------------*/
-bool CEIMBase::Measure(
-    QImage			*h_image,
-	const Point	&point1,
-	const Point	&point2,
-	bool			fDiameter,
-	CEIMResult		*m_res)
-{
-	m_image = h_image;
-	return Measure( point1, point2, fDiameter, m_res );
-}
-
-bool CEIMBase::Measure (
-	const Point   &point1,
-	const Point   &point2,
-	bool           fDiameter,
-	CEIMResult     *m_res
-)
-{
-	Point point3, point4;
-
-	//	En fonction de la position du premier point, on d�termine le c�t� d'analyse
-	m_fDiameter  = fDiameter;
-	Release ();
-
-	if (point1.x > point2.x) 
-	{
-		m_bNearWall = true;
-		m_vUser = CVector(point2, point1);
-		if (!fDiameter)
-		{
-			m_StartPoint = point2;
-			m_EndPoint = point1; 
-		}
-	}
-	else 
-	{
-		m_bNearWall = false; 
-		m_vUser = CVector(point1, point2);	//	pour imposer le calcul de gauche � droite pour 
-							//	le diam�tre et la distensibilit� m�me si le trac�
-							//	se fait de droite � gauche.
-		if (!fDiameter)
-		{
-			m_StartPoint = point1;
-			m_EndPoint = point2; 
-		}
-	}
-
-	m_minx_curve = std::numeric_limits< int >::max(); 
-	m_max_curve = 0; 
-/*
-	if ((m_Assist) && (!fDiameter)) 
-	{
-		// CJ 2007 : Allongement auto de la distance � 10 mm 
-		dpoint pta, ptb, s1, s2, ptc;
-		const long x1 = 0;
-
-		pta.x = point1.x; 
-		pta.y = point1.y; 
-		ptb.x = point2.x; 
-		ptb.y = point2.y;
-
-		if (point1.x < point2.x) 
-		{
-			if (InterCercleDroite(pta, 10.0 / g_pCurrentScale->DistanceX(1L), pta, ptb, &s1, &s2))
-			{
-				ptc = leplusproche(ptb, s1, s2);
-				point3.x = (int) pta.x;
-				point3.y = (int) pta.y;
-				point4.x = (int) ptc.x;
-				point4.y = (int) ptc.y;
-			}
-
-#ifndef NEW_EIM
-			m_vUser = CVector (point3, point4);
-#else
-			if (point3.x <= point4.x) 
-			{
-				m_vUser = CVector (point3, point4);
-				m_StartPoint = point3;
-				m_EndPoint = point4; 
-			}
-			else 
-			{
-				m_vUser = CVector (point4, point3);
-				m_StartPoint = point4;
-				m_EndPoint = point3; 
-			}
-			
-			if (point4.x > point3.x)
-			{
-				m_max_curve = point4.x;
-			}
-			else
-			{
-				m_max_curve = point3.x;
-			}
-
-			if (point3.x < point4.x) 
-			{
-				m_minx_curve = point3.x;
-			}
-			else
-			{
-				m_minx_curve = point4.x;
-			}
-#endif
-		}
-	}
-*/
-	if (m_vUser.Nul ())
-	{
-		m_uErrorID = IDS_EIM_INVALID;
-		return (false);
-	}
-	else
-	{
-//		CWaitCursor wait;
-
-		m_dwPoints  = m_vUser.Length () + 1;
-		m_pMeasures = new CEIMInfo [m_dwPoints];
-		memset (m_pMeasures, 0, sizeof (CEIMInfo) * m_dwPoints);
-		// pour un algo plut�t bas� sur la proximit� de la droite par
-		//    rapport � la paroi potentielle la plus proche voir fichier EIM/AvecSeuil.cpp
-		// comme le point de d�part de vecteur � toujours une abscisse inf�rieure au point d'arriv�e
-		//    la direction � donner � Orthogonal est 0. Voir algo de Orthogonal pour comprendre
-		
-		if (!m_bNearWall)
-		{
-			m_indexParoi = 0; 
-			m_Max_Alignement = 8; 
-		}
-		else
-		{
-			m_indexParoi = 1; 
-			m_Max_Alignement = 20; 
-		}
-
-		if (fDiameter) 
-		{
-			Diameter();
-		}
-		else
-		{
-#ifdef NEW_EIM
-			if (!m_Assist)
-#else
-//			if ((m_Assist) && (!fDiameter)) 
-			{
-			}
-//			else
-#endif
-			{
-				m_vUser = CVector (point1, point2);
-			}
-
-			Paroi();
-		}
-	}
-
-	Update (m_res);
-	return (Valid ());
-} // fin de Measure
-
-/*----------------------------------------------------------\
-|                     ParallelismeEIM                          |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Fonction de calcul du parall�lisme du trait utilisateur  |
-|  Par rapport � la paroi 
-|  Pour le calcul de l'EIM                                  |
-\----------------------------------------------------------*/
-void CEIMBase::ParallelismeEIM()
-{
-	long dwPos, dwMin;
-	long dwPos2;
-	CEIMInfo *pInfo = &m_pMeasures[0];
-	dpoint tpoints[MAX_POINTS_EIM_AUTO]; 
-	int  tContinueGauche[MAX_POINTS_EIM_AUTO]; 
-	int  tContinueDroite[MAX_POINTS_EIM_AUTO]; 
-	int  tContinue[MAX_POINTS_EIM_AUTO]; 
-	int  tContinue2[MAX_POINTS_EIM_AUTO]; 
-	dpoint pta, ptb, ptc, ptd, pte, ptf, s1, s2; 
-	double dist_etalon, dist_etalon2, dist; 
-	int cptValid, cptNonValid; 
-	dpoint tabPointsValides[128]; 
-	dpoint pts;
-	bool bDebut = false; 
-
-	for (int i = 0; i < MAX_POINTS_EIM_AUTO; i++) 
-	{
-		tContinueGauche[i] = 0; 
-		tContinueDroite[i] = 0; 
-		tContinue[i] = 0;
-		tContinue2[i] = 0;
-	}
-
-	// 2�me passe : On enl�ve les outliers : En allant de gauche � droite 
-	dwMin = long (-1);
-	pInfo = &m_pMeasures[0];
-	cptValid = 0; 
-	cptNonValid = 0; 
-//	double dist2, dist3; 
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (pInfo->m_fValid == true)
-		{
-			pts.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-			pts.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-
-			if ((pts.x != 0) && (pts.y != 0))
-			{
-				// V�rification de l'alignement 
-				if (cptValid >= m_Max_Alignement)
-				{
-					// Estimation droite � partir de tabPointsValides 
-					double ka, kb;
-					RegressionLineaire(m_Max_Alignement, tabPointsValides, &ka, &kb);
-
-					// Calcul de la distance orthogonale entre la droite et pts 
-					dpoint ptk, ptl, ptr;
-					ptk.x = pts.x;
-					ptk.y = ka * pts.x + kb; 
-					ptl.x = pts.x + 10;
-					ptl.y = ka * ptl.x + kb; 
-
-					dist = distanceOrthPtDroite(pts, ptk, ptl, &ptr);
-
-					if (dist < 3) // Si la distance est < � n pixels 
-					{
-						cptNonValid = 0; // On remet le compteur � 0
-						// Ce point est OK, on le garde  
-						// Remise � jour du tableau des points 
-						for (int i = 0; i < m_Max_Alignement-1; i++) 
-						{
-							tabPointsValides[i].x = tabPointsValides[i+1].x;
-							tabPointsValides[i].y = tabPointsValides[i+1].y;
-						}
-
-						tabPointsValides[m_Max_Alignement-1].x = pts.x; 
-						tabPointsValides[m_Max_Alignement-1].y = pts.y; 
-						tContinueGauche[dwPos] = 1; 
-					}
-					else
-					{
-						cptNonValid++; // Nb de points non valides � la suite
-					}
-
-					// Si un nombre de points non valides suffisant a �t� d�tect� � la suite 
-					if (cptNonValid >= m_Max_Alignement - 1)
-					{
-						// On remet � 0 le tableau des valeurs
-						for (int i = 0; i < m_Max_Alignement-1; i++) 
-						{
-							tabPointsValides[i].x =  0;
-							tabPointsValides[i].y =  0;
-						}
-						cptValid = 0; // On redemande un remplissage
-						cptNonValid = 0; 
-					}
-				}
-				else
-				{
-					tabPointsValides[0].x = pInfo->m_Paroi[m_indexParoi].m_slope[2].m_ptDraw.x;
-					tabPointsValides[0].y = pInfo->m_Paroi[m_indexParoi].m_slope[2].m_ptDraw.y;
-					cptValid++; 
-				}
-			}
-		}
-		pInfo++;
-	}
-	
-	// Puis de droite � gauche
-	pInfo = &m_pMeasures[m_dwPoints-1];
-	cptValid = 0; 
-	cptNonValid = 0; 
-	bDebut = false; 
-	for (dwPos = m_dwPoints-1; dwPos > 0; dwPos--)
-	{
-		if (pInfo->m_fValid == true)
-		{
-			pts.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-			pts.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-			if ((pts.x != 0) && (pts.y != 0))
-			{
-				// V�rification de l'alignement 
-				if (cptValid >= m_Max_Alignement)
-				{
-					// Estimation droite � partir de tabPointsValides 
-					double ka, kb;
-					RegressionLineaire(m_Max_Alignement, tabPointsValides, &ka, &kb);
-
-					// Calcul de la distance orthogonale entre la droite et pts 
-					dpoint ptk, ptl, ptr;
-					ptk.x = pts.x;
-					ptk.y = ka * pts.x + kb;
-					ptl.x = pts.x + 10;
-					ptl.y = ka * ptl.x + kb;
-
-					dist = distanceOrthPtDroite(pts, ptk, ptl, &ptr);
-
-					if (dist < 3) // Si la distance est < � x pixels 
-					{
-						cptNonValid = 0; // On remet le compteur � 0
-						// Ce point est OK, on le garde  
-						// Remise � jour du tableau des points 
-						for (int i = 0; i < m_Max_Alignement-1; i++) 
-						{
-							tabPointsValides[i].x =  tabPointsValides[i+1].x;
-							tabPointsValides[i].y =  tabPointsValides[i+1].y;
-						}
-
-						tabPointsValides[m_Max_Alignement-1].x = pts.x; 
-						tabPointsValides[m_Max_Alignement-1].y = pts.y; 
-						tContinueDroite[dwPos] = 1; 
-					}
-					else
-					{
-						cptNonValid++; // Nb de points non valides � la suite
-					}
-
-					// Si un nombre de points non valides suffisant a �t� d�tect� � la suite 
-					if (cptNonValid >= m_Max_Alignement - 1)
-					{
-						// On remet � 0 le tableau des valeurs
-						for (int i = 0; i < m_Max_Alignement-1; i++) 
-						{
-							tabPointsValides[i].x =  0;
-							tabPointsValides[i].y =  0;
-						}
-						cptNonValid = 0; 
-						cptValid = 0; // On redemande un remplissage
-					}
-				}
-				else
-				{
-					tabPointsValides[cptValid].x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-					tabPointsValides[cptValid].y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-
-					cptValid++; 
-				}
-			}
-		}
-		pInfo--;
-	}
-
-	pInfo = &m_pMeasures[0];
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (pInfo->m_fValid == true)
-		{
-			if ((tContinueGauche[dwPos] == 1) || (tContinueDroite[dwPos] == 1))
-			{
-				tContinue[dwPos] = 1;
-			}
-		}
-		tContinue2[dwPos] = tContinue[dwPos];
-		pInfo++;
-	}
-
-	bool bNonContinue = false; 
-	int  cptNonContinue = 0; 
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (tContinue2[dwPos] == 1) 
-		{ 
-			cptNonContinue = 0;
-		}
-		else if (tContinue2[dwPos] == 0)
-		{
-			cptNonContinue++; 
-			bNonContinue = true; 
-		}
-
-		// 1- On faits rejoindre les segments si l'�cart est faible (sur front montant)
-		if ((tContinue2[dwPos] == 1) && bNonContinue)
-		{
-			bNonContinue = false; 
-			if (cptNonContinue < 3*m_Max_Alignement)
-			{
-				// Dans ce cas on peut rejoindre les 2 segments 
-				for (dwPos2 = dwPos - 3*m_Max_Alignement; dwPos2 < dwPos; dwPos2++)
-				{
-					if (dwPos2 >= 0)
-					{
-						tContinue2[dwPos2] = 1; 
-					}
-				}
-			}
-		}
-	}
-
-	int indexSegments = 0; 
-	bNonContinue = true;
-	int maxSegment = 0; 
-	int longueurSegment = 0; 
-	int indexMaxSegment = 1; 
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (tContinue2[dwPos] == 0)
-		{
-			bNonContinue = true; 
-		}
-
-		if ((tContinue2[dwPos] == 1) && bNonContinue)
-		{
-			indexSegments++;
-			bNonContinue = false;	
-			longueurSegment = 0; 
-		}
-
-		// 2 - On num�rote chacun des segments
-		if (tContinue2[dwPos] == 1)
-		{
-			tContinue2[dwPos] = indexSegments;
-
-			longueurSegment++;
-			if (longueurSegment > maxSegment) 
-			{
-				maxSegment = longueurSegment; 
-				indexMaxSegment = indexSegments;
-			}
-		}
-	}
-
-	// 3 - Si plus de 1 segment on regarde celui qui est le plus grand
-	if (indexSegments > 1) 
-	{
-		for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-		{
-			if (tContinue2[dwPos] != indexMaxSegment)
-			{
-				// 4- On efface les traits continus des segments qui ne sont pas le plus long 
-				tContinue[dwPos] = 0; 
-			}
-		}
-	}
-
-	dwMin = long (-1);
-	pInfo = &m_pMeasures[0];
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		pInfo->m_fValid = (tContinue[dwPos] == 1);
-
-		pInfo++;
-	}
-
-	dwMin = long (-1);
-	pInfo = &m_pMeasures[0];
-	dist_etalon = 0; 
-	dist_etalon2 = 0; 
-	m_nbpoints_curve = 0; 
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (pInfo->m_fValid == true)
-		{
-			// Au premier point on m�morise la valeur de la distance qui va servir d'�talon pour les autres points
-			pta.x = m_vUser[dwPos].x;
-			pta.y = m_vUser[dwPos].y;
-
-			ptb.x = pInfo->m_Paroi[0].m_slope[2].m_ptMiddle.x;
-			ptb.y = pInfo->m_Paroi[0].m_slope[2].m_ptMiddle.y;
-			pte.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-			pte.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-			ptf.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-			ptf.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-
-			if (m_nbpoints_curve == 0) 
-			{
-				dist_etalon = distance(pta, ptb);
-				dist_etalon2 = distance(pta, pte);
-				tpoints[0].x = m_vUser[dwPos].x;
-				tpoints[0].y = m_vUser[dwPos].y;
-				m_nbpoints_curve++;
-			}
-			else
-			{
-				bool outOfImage; 
-				outOfImage = false; 
-				// Intersection entre le cercle centr� sur ptb de rayon dist_etalon, et la droite pta, ptb
-				if (InterCercleDroite(ptb, dist_etalon, pta, ptb, &s1, &s2))
-				{
-					// Renvoie le point le plus proche de pta 
-					// Qui va �tre le nouveau point 
-					ptc = leplusproche(pta, s1, s2);
-					
-					dist = distance(ptc, pta);
-					// Contre les bugs aux extr�mit�s des images 
-					if (dist <= (2 * dist_etalon))
-					//if ((ptc.x <= m_rectCadre.GetRight()) && (ptc.x >= m_rectCadre.GetLeft()))
-					{
-						tpoints[m_nbpoints_curve].x = ptc.x;
-						tpoints[m_nbpoints_curve].y = ptc.y;
-					}
-					else
-					{
-						outOfImage = true;
-					}
-				}
-				else
-				{
-					tpoints[m_nbpoints_curve].x = m_vUser[dwPos].x;
-					tpoints[m_nbpoints_curve].y = m_vUser[dwPos].y;
-				}
-
-				if (!outOfImage)
-				{
-					m_nbpoints_curve++; 
-				}
-			}
-		}
-
-		pInfo++;
-	}
-
-	moindres_carres_parabole(m_nbpoints_curve, tpoints, &m_coeff_a, &m_coeff_b, &m_coeff_c);
-
-	CVector vPerp; 
-	Point point1, point2, point3; 
-
-	// On recalcul l'EIM, en utilisant cette fois les perpendiculaires � la courbe obtenue
-	dwMin = long (-1);
-	int i; 
-	i = 0; 
-	pInfo = &m_pMeasures[0];
-	bool bDistDeb; 
-	bDistDeb = false; 
-	double ka, kb;
-	bDebut = false;
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		if (pInfo->m_fValid == true) 
-		{
-			pta.x = tpoints[i].x;
-			pta.y = tpoints[i].y;
-
-			// La tangente (d�riv�e) de y = ax2 + b x + c est y = 2ax + b
-			// Le coefficient directeur de la perpendiculaire � la tangente est -1/b 
-			// Pour la perpendiculaire qui passe par pta.x, pta.y, y = ka x + kb
-			if (m_coeff_b != 0)
-			{
-				ka = (double) -1.0 / (2 * m_coeff_a);
-			}
-			else
-			{
-				ka = 0.0;
-			}
-
-			kb = pta.y - ka * pta.x;
-
-			ptb.y = tpoints[i].y + 2 * dist_etalon;
-			if (ka != 0)
-			{
-				ptb.x = (ptb.y - kb) / ka;
-			}
-			else
-			{
-				ptb.x = tpoints[i].x;
-			}
-
-			// Intersection entre le cercle centr� sur pta de rayon dist_etalon, et la droite pta, ptb
-			bool bInter = InterCercleDroite(pta, 2 * dist_etalon2, pta, ptb, &s1, &s2);
-
-			if (bInter)
-			{
-				if (m_bNearWall)
-				{
-					if (s1.y <= s2.y) 
-					{
-						ptc.x = s1.x; 
-						ptc.y = s1.y;
-						ptd.x = s2.x; 
-						ptd.y = s2.y;
-					}
-					else
-					{
-						ptc.x = s2.x; 
-						ptc.y = s2.y;
-						ptd.x = s1.x; 
-						ptd.y = s1.y;
-					}
-				}
-				else
-				{
-					if (s1.y > s2.y) 
-					{
-						ptc.x = s1.x; 
-						ptc.y = s1.y;
-						ptd.x = s2.x; 
-						ptd.y = s2.y;
-					}
-					else
-					{
-						ptc.x = s2.x; 
-						ptc.y = s2.y;
-						ptd.x = s1.x; 
-						ptd.y = s1.y;
-					}
-				}
-			}
-			else
-			{
-				ptc.x = ptb.x; 
-				ptc.y = ptb.y; 
-				ptd.x = ptb.x; 
-				ptd.y = ptb.y; 
-			}
-
-			point1.x = (int) pta.x;
-			point1.y = (int) pta.y;
-
-			point2.x = (int) ptc.x;
-			point2.y = (int) ptc.y;
-
-			point3.x = (int) ptd.x;
-			point3.y = (int) ptd.y;
-
-			m_pt1perp[i].x = point1.x;
-			m_pt1perp[i].y = point1.y;
-
-			m_pt2perp[i].x = point2.x;
-			m_pt2perp[i].y = point2.y;
-
-	 		i++;
-	 	}
-	
-		pInfo++;		
- 	}
-/* Enlev� 	
-	// Calculs aux extr�mit�s 
-	// Au d�but 
-	dpoint pt0, pt1;
-	pt0.x = debx; 
-
-	// y = ax2 + b x + c
-	pt0.y = (m_coeff_a * pt0.x * pt0.x) + (m_coeff_b * pt0.x) + m_coeff_c;
-
-	// La tangente (d�riv�e) de y = ax2 + b x + c est y = 2ax + b
-	// Le coefficient directeur de la perpendiculaire � la tangente est -1/b 
-	double ka, kb;
-	// Pour la perpendiculaire qui passe par pta.x, pta.y, y = ka x + kb
-	if (m_coeff_b != 0) 
-	{
-		ka = (double) -1.0 / (2 * m_coeff_a);
-	}
-	else
-	{
-		ka = 0.0; 
-	}
-
-	kb = pt0.y - ka * pt0.x; 
-	double kb2 = m_coeff_b; 
-
-	pt1.y = pt0.y + 2 * dist_etalon;
-	if (ka != 0)
-	{
-		pt1.x = (pt1.y - kb) / ka; 
-	}
-	else
-	{
-		pt1.x = pt0.x; 
-	}
-
-	// Intersection entre le cercle centr� sur pt0 de rayon dist_etalon, et la droite xd,yd, ptcel
-	if (InterCercleDroite(pt0, dist_Debut, pt0, pt1, &s1, &s2))
-	{
-		dist2 = distance(s1, ptdeb); 
-		dist3 = distance(s2, ptdeb);
-		if (dist2 < dist3) 
-		{
-			m_ptDebut.x = (int) s1.x;
-			m_ptDebut.y = (int) s1.y;
-		}
-		else
-		{
-			m_ptDebut.x = (int) s2.x;
-			m_ptDebut.y = (int) s2.y;
-		}
-	}
-	// A la fin 
-	pt0.x = finx; 
-
-	// y = ax2 + b x + c
-	pt0.y = (m_coeff_a * pt0.x * pt0.x) + (m_coeff_b * pt0.x) + m_coeff_c;
-
-	// La tangente (d�riv�e) de y = ax2 + b x + c est y = 2ax + b
-	// Le coefficient directeur de la perpendiculaire � la tangente est -1/b 
-	// Pour la perpendiculaire qui passe par pta.x, pta.y, y = ka x + kb
-	if (m_coeff_b != 0) 
-	{
-		ka = (double) -1.0 / (2 * m_coeff_a);
-	}
-	else
-	{
-		ka = 0.0; 
-	}
-
-	kb = pt0.y - ka * pt0.x; 
-	kb2 = m_coeff_b; 
-
-	pt1.y = pt0.y + 2 * dist_etalon;
-	if (ka != 0)
-	{
-		pt1.x = (pt1.y - kb) / ka; 
-	}
-	else
-	{
-		pt1.x = pt0.x; 
-	}
-
-	// Intersection entre le cercle centr� sur pt0 de rayon dist_etalon, et la droite xd,yd, ptcel
-	if (InterCercleDroite(pt0, dist_Fin, pt0, pt1, &s1, &s2))
-	{
-		dist2 = distance(s1, ptfin); 
-		dist3 = distance(s2, ptfin);
-		if (dist2 < dist3)
-		{
-			m_ptFin.x = (int) s1.x;
-			m_ptFin.y = (int) s1.y;
-		}
-		else
-		{
-			m_ptFin.x = (int) s2.x;
-			m_ptFin.y = (int) s2.y;
-		}
-	}
-*/
-}
-
-/*----------------------------------------------------------\
-|                          Paroi                            |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Calcul de l'�paisseur d'une paroi dans une zone donn�e   |
-\----------------------------------------------------------*/
-void CEIMBase::Paroi()
-{
-	long dwPos, dwMin, dwFirst;
-	int debx, finx;
-	CEIMInfo *pInfo = &m_pMeasures[0];
-#ifdef NEW_EIM
-	double dist_Debut, dist_Fin; 
-	dpoint pts;
-#endif 
-	bool bDebut = false; 
-	dpoint ptdeb, ptfin; 
-	
-	ptdeb.x = ptfin.x = 0;
-	ptdeb.y = ptfin.y = 0;
-
-	m_nbpoints_curve = 0; 
-
-	m_coeff_a = -1.0; 
-	m_coeff_b = -1.0; 
-	m_coeff_c = -1.0; 
-
-	assert(!m_fDiameter && m_pMeasures && GfxImageValid());
-
-	dwMin = long (-1);
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		// Ligne perpendiculaire � la paroi sur laquelle effectuer la mesure
-		pInfo->m_Paroi[0].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 0);
-
-		if (AddVector(pInfo->m_Paroi[0]))
-		{
-			ComputeEIM(pInfo);
-
-			// recherche des premi�res position valides, afin de r�duire l'�tendue de l'histogramme
-			dwFirst = pInfo->m_Paroi[0].m_slope[0].m_dwPos[0];
-			if (dwFirst < dwMin)
-			{
-				dwMin = dwFirst;
-			}
-			if (bDebut == false) 
-			{
-				bDebut = true; 
-				debx = m_vUser[dwPos].x;
-#ifndef NEW_EIM
-				ptdeb.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-				ptdeb.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-#endif 
-			}
-
-#ifndef NEW_EIM
-			ptfin.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-			ptfin.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-#endif
-			finx = m_vUser[dwPos].x;
-		}
-		else
-		{
-			pInfo->m_fValid = false;
-		}
-
-		pInfo->m_diagnostic = m_diag; 
-		pInfo++;
-	}
-
-#ifdef NEW_EIM
-	// Modif CJ2007 
-	if (m_Assist) 
-	{
-		ParallelismeEIM(); 
-
-		CVector vPerp; 
- 
-		// On recalcul l'EIM, en utilisant cette fois les perpendiculaires � la courbe obtenue
-		dwMin = long (-1);
-		int i; 
-		i = 0; 
-		pInfo = &m_pMeasures[0];
-		bool bDistDeb; 
-		bDistDeb = false; 
-		bDebut = false;
-		for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-		{
-			if (pInfo->m_fValid == true)
-			{
-				if ((m_pt1perp[i].y >= 0) && (m_pt2perp[i].y >= 0) && (m_pt1perp[i].x >= 0) && (m_pt2perp[i].x >= 0)
-				&& (m_pt1perp[i].y < 576) && (m_pt2perp[i].y < 576) && (m_pt1perp[i].x < 768) && (m_pt2perp[i].x < 768))
-				{
-					pInfo->m_Paroi[0].m_vMeasure = CVector(m_pt1perp[i], m_pt2perp[i]);		
- 				
-					if (AddVector(pInfo->m_Paroi[0]))
-					{
-	 					ComputeEIM(pInfo);
-
-						// Recherche des premi�res position valides, afin de r�duire l'�tendue de l'histogramme
-						dwFirst = pInfo->m_Paroi[0].m_slope[0].m_dwPos[0];
-						if (dwFirst < dwMin)
-						{
-							dwMin = dwFirst;
-						}
-
-						if (bDebut == false) 
-						{
-							bDebut = true; 
-							ptdeb.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-							ptdeb.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-						}
-
-						ptfin.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-						ptfin.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-
-						dpoint ptt, ptr;
-						ptt.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-						ptt.y = (m_coeff_a * ptt.x * ptt.x) +  (m_coeff_b * ptt.x) + m_coeff_c;
-						ptr.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-						ptr.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-						if (!bDistDeb)
-						{
-							bDistDeb = true; 
-							dist_Debut = distance(ptt, ptr); 
-						}
-						dist_Fin = distance(ptt, ptr); 
-					}
-					else
-					{
-	 					pInfo->m_fValid = false;
-					}	
-
- 					pts.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-		 		}
-		 		i++;
-		 	}
-		
-			pInfo++;		
-	 	}
-	}
-#endif 
-
-	if (ptdeb.x < ptfin.x)
-	{
-		m_ptDebut.x = (long) ptdeb.x; 
-		m_ptFin.x = (long) ptfin.x; 
-	}
-	else
-	{
-		m_ptDebut.x = (long) ptfin.x; 
-		m_ptFin.x = (long) ptdeb.x; 
-	}
-
-
-	// Ajustement des vecteurs de mesures et des positions
-	pInfo = &m_pMeasures[0];
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		pInfo->m_Paroi[0].m_slope[0].m_dwPos[0] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[0].m_dwPos[1] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[0].m_dwMiddle -= dwMin;
-		pInfo->m_Paroi[0].m_slope[1].m_dwPos[0] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[1].m_dwPos[1] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[1].m_dwMiddle -= dwMin;
-		pInfo->m_Paroi[0].m_slope[2].m_dwPos[0] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[2].m_dwPos[1] -= dwMin;
-		pInfo->m_Paroi[0].m_slope[2].m_dwMiddle -= dwMin;
-		pInfo->m_Paroi[0].m_vMeasure = CVector(pInfo->m_Paroi[0].m_vMeasure[dwMin], pInfo->m_Paroi[0].m_vMeasure.EndPoint());
-		pInfo++;
-	}
-} // end of Paroi
-
-/*-----------------------------------------------------------\
-|                ParallelismeDistensibilite                 |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Fonction de calcul du parall�lisme du trait utilisateur  |
-|  Par rapport � la paroi                                   |
-|  Pour le calcul du diam�tre pour la distensibilit�        |
-\----------------------------------------------------------*/
-void CEIMBase::ParallelismeDistensibilite()
-{
-	int nbOk;
-	long dwPos;
-	dpoint pta, ptb, ptc, s1, s2;
-	double distMoy, sommeDist;
-	dpoint tpoints[MAX_POINTS_EIM_AUTO];
-	double ka, kb;
-	Point vp1, vp2;
-	bool bInter;
-	CEIMInfo *pInfo;
-
-	ka = 0; 
-	kb = 0; 
-	// 1)- On va estimer la distance du milieu de la veine sur les points valides 
-	nbOk = 0;
-	distMoy = 0;
-	sommeDist = 0;
-	pInfo = &m_pMeasures [0];
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		pInfo->m_Paroi[0].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 0);
-		// pour l'histogramme, le deuxi�me vecteur est requis m�me si la mesure a �chou�
-		pInfo->m_Paroi[1].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 1);
-
-		if (AddVector(pInfo->m_Paroi [0])
-		  && ((m_algoDiameter == algoProfile) ?
-				AddVector(pInfo->m_Paroi [1]) :                   // recherche d'un profil sur la paroi sup�rieure
-				FindOpposite(pInfo->m_Paroi[0], pInfo->m_Paroi[1]) // recherche sur la paroi sup�rieure du sym�trique de la paroi inf�rieure
-		      )
-		   )
-		{
-			ComputeEIM(pInfo);
-
-			distMoy = (pInfo->m_dblDia / 2.0);
-			sommeDist += distMoy;
-			nbOk++;
-		}
-		pInfo++;
-	}
-
-	if (nbOk > 0)  
-	{
-		distMoy = sommeDist / nbOk;
-
-		// 2)- On va d�terminer les points au centre  
-		pInfo = &m_pMeasures [0];
-		m_nbpoints_curve = 0;
-		nbOk = 0;
-		for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-		{
-			pInfo->m_Paroi[0].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 0);
-
-			// On regarde que la paroi du bas pour le parall�lisme
-			if (AddVector(pInfo->m_Paroi [0]))
-			{
-				ComputeEIM(pInfo);
-
-				// Au premier point on m�morise la valeur de la distance qui va servir d'�talon pour les autres points
-				pta.x = m_vUser[dwPos].x;
-				pta.y = m_vUser[dwPos].y;
-
-				ptb.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-				ptb.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-				
-				// Intersection cercle centr� sur ptb 
-				bInter = InterCercleDroite(ptb, distMoy, pta, ptb, &s1, &s2);
-
-				// On prend celui qui est le plus pr�s de pta 
-				ptc = leplusproche(pta, s1, s2);
-
-				// On stocke le point trouv� pour faire l'approximation 
-				tpoints[nbOk].x = ptc.x;
-				tpoints[nbOk].y = ptc.y;
-				nbOk++; 
-			}
-			pInfo++;
-		}
-
-		if (nbOk > 4) // Plusieurs points sinon �rron�s 
-		{
-			// Alors on approxime les points par une droite 
-			RegressionLineaire(nbOk, tpoints, &ka, &kb);
-
-			// On met � jour m_vUser en fonction de la droite approxim�e : il va �tre utilis� par la suite 
-			vp1.x = m_vUser[0].x; 
-			vp1.y = (int) ((double) ka * vp1.x + kb); 
-
-			vp2.x = m_vUser[dwPos].x; 
-			vp2.y = (int) ((double) ka * vp2.x + kb); 
-
-			// On d�termine les nouvelles valeurs de m_vUser 
-			// Et c'est celui l� qui va �tre utilis� dans la fonction de base  
-
-			m_vUser = CVector (vp1, vp2);
-
-			m_StartPoint.x = vp1.x;
-			m_StartPoint.y = vp1.y;
-
-			m_EndPoint.x = vp2.x;
-			m_EndPoint.y = vp2.y;
-		}
-		else
-		{
-			m_StartPoint.x = m_vUser[0].x;
-			m_StartPoint.y = m_vUser[0].y;
-
-			m_EndPoint.x = m_vUser[1].x;
-			m_EndPoint.y = m_vUser[1].y;
-		}
-		// Les calculs de base vont se faire avec le nouvel m_vUser calcul� 
-	}	
-}
-
-/*----------------------------------------------------------\
-|                         Diameter                          |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Mesure du diam�tre d'un vaisseau                         |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pScale  : �chelle � utiliser pour les mesures            |
-|  gfx     : image en niveau de gris d'o� lire les donn�es  |
-|  pt1     : premier point du segment d�terminant la ligne  |
-|              de la paroi.                                 |
-|  pt2     : deuxi�me point du segment                      |
-\----------------------------------------------------------*/
-void CEIMBase::Diameter()
-{
-	CEIMInfo *pInfo;
-	long dwMin [2], dwPos, dwFirst;
-	
- 	assert (m_fDiameter && m_pMeasures && GfxImageValid());
-
-	if (m_parallelismeDiametre)
-	{
-		ParallelismeDistensibilite();
-	}
-
-	dwMin[0] = long(-1);
-	dwMin[1] = long(-1);
-	bool bDistDeb, bDebut; 
-	bDistDeb = false; 
-	bDebut = false;
-	pInfo = &m_pMeasures[0];
-
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		pInfo->m_Paroi[0].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 0);
-
-		// Pour l'histogramme, le deuxi�me vecteur est requis m�me si la mesure a �chou�
-
-		pInfo->m_Paroi[1].m_vMeasure = m_vUser.Orthogonal(m_vUser[dwPos], 1);
-
-		if   (  AddVector(pInfo->m_Paroi [0])
-		  && (	(m_algoDiameter == algoProfile) ?
-				AddVector(pInfo->m_Paroi [1]) :                   // recherche d'un profil sur la paroi sup�rieure
-				FindOpposite (pInfo->m_Paroi[0], pInfo->m_Paroi[1]) // recherche sur la paroi sup�rieure du sym�trique de la paroi inf�rieure
-		     )
-		   )
-		{
-			ComputeEIM (pInfo);
-			// recherche des premi�res position valides, afin de r�duire l'�tendue de l'histogramme
-			for (int j = 0; j < 2; j++)
-			{
-				dwFirst = pInfo->m_Paroi[j].m_slope[0].m_dwPos[0];
-				if (dwFirst < dwMin [j])
-					dwMin[j] = dwFirst;
-			}
- 		}
-		else
-		{
-			// recalcul syst�matique, car cette fonction est appel� lors de la modification des seuils
-			pInfo->m_fValid = false;
-		}
-		pInfo++;
-	}
-
-	// ajustement des vecteurs de mesures et des positions
-	pInfo = &m_pMeasures [0];
-	for (dwPos = 0; dwPos < m_dwPoints; dwPos++)
-	{
-		for (int i = 0; i < 2; i++)
-		{
-			pInfo->m_Paroi[i].m_slope[0].m_dwPos[0] -= dwMin[i];
-			pInfo->m_Paroi[i].m_slope[0].m_dwPos[1] -= dwMin[i];
-			pInfo->m_Paroi[i].m_slope[0].m_dwMiddle -= dwMin[i];
-			pInfo->m_Paroi[i].m_slope[1].m_dwPos[0] -= dwMin[i];
-			pInfo->m_Paroi[i].m_slope[1].m_dwPos[1] -= dwMin[i];
-			pInfo->m_Paroi[i].m_slope[1].m_dwMiddle -= dwMin[i];
-			pInfo->m_Paroi[i].m_vMeasure = CVector (pInfo->m_Paroi[i].m_vMeasure[dwMin[i]], pInfo->m_Paroi[i].m_vMeasure.EndPoint());
-		}
-		pInfo++;
-	}
-} // end of Diameter
-
-/*----------------------------------------------------------\
-|                    CEIM::AddVector                        |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Calcul de l'�paisseur d'une paroi dans une zone donn�e   |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  paroi : CEIMInfo � remplir avec les mesures              |
-\----------------------------------------------------------*/
-bool CEIMBase::AddVector(sParoi &paroi)
-{
-	long dwPoint, dwLast = THICKNESS - 1; // le dernier point sur lequel effectuer une mesure (au pire)
-
-	// on s'assure que le vecteur ne d�passe pas la zone d'affichage
-	// paroi.m_vMeasure.Mask      (*m_pGfx); dwLast = min( dwMax, m_vMeasure.Length())
-	assert (PointInBuffer (paroi.m_vMeasure [0]));
-
-	// afin de traiter la variation d'intensit� en m�me temps, on r�cup�re le premier
-	// point ind�pendamment des autres
-	// ASSERT ((paroi.m_vMeasure [0].x != 301) && (paroi.m_vMeasure [0].x != 336));
-	m_bBuffer [0] = GetIntensity (paroi.m_vMeasure [0]);
-
-	for (dwPoint = 1; dwPoint <= dwLast; dwPoint++)
-	{
-		const Point &pt = paroi.m_vMeasure [dwPoint];
-
-		if (PointInBuffer (pt))
-		{
-			// remplissage de la m�moire tampon
-			m_bBuffer  [dwPoint] = GetIntensity (pt);
-			// calcul de la variation de densit�
-			m_cOffsets [dwPoint] = Delta (m_bBuffer [dwPoint], m_bBuffer [dwPoint - 1]);
-		}
-		else // peu �l�gant, mais efficace
-		{
-			dwLast = dwPoint - 1; // interrompra �galement la prochaine boucle (de d�tection de profil)
-		}
-	}
-
-	// On mesure l'E.I.M. sur la ligne extraite
-
-	if (m_versionTomtecAout08)
-	{
-		// Pour pouvoir afficher les points milieux m�me s'ils sont pas valides 
-		int res = MeasureLineBuffer (paroi, m_bBuffer, m_cOffsets, dwPoint);
-		{
-			SetMiddlePoint (paroi.m_slope [0], paroi.m_vMeasure);
-			SetMiddlePoint (paroi.m_slope [1], paroi.m_vMeasure);
-
-			// On mesure l'IMT sur la ligne extraite
-			SetMiddlePoint (paroi.m_slope [2], paroi.m_vMeasure, true);
-	      
-			if (res) 
-			{
-				return (true);
-			}
-		}
-	}
-	else
-	{
-		if (MeasureLineBuffer (paroi, m_bBuffer, m_cOffsets, dwPoint) > 0)
-		{
-			SetMiddlePoint (paroi.m_slope [0], paroi.m_vMeasure);
-			SetMiddlePoint (paroi.m_slope [1], paroi.m_vMeasure);
-
-			// On mesure l'IMT sur la ligne extraite
-			SetMiddlePoint (paroi.m_slope [2], paroi.m_vMeasure, true);
-	      
-			return (true);
-		}
-	}
-
-	return (false);
-} // end of AddVector
-
-/*----------------------------------------------------------\
-|                      FindOpposite                         |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Recherche le point adventice sym�trique|
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  paroi : CEIMInfo � remplir avec les mesures              |
-\----------------------------------------------------------*/
-bool CEIMBase::FindOpposite(sParoi &paroi1,	sParoi &paroi0)
-{
-	long dwSeek = paroi0.m_slope[0].m_dwIntensity, 
-		  dwMax  = GetIntensity(paroi1.m_vMeasure[paroi0.m_slope[1].m_dwPos[1]]),
-          dwPoint;
-	bool  fFound, fInGfx;
-
-	// afin de traiter la variation d'intensit� en m�me temps, on r�cup�re le premier
-	//    point ind�pendamment des autres
-	dwPoint = 0;
-	fFound  = false;
-	fInGfx  = true;
-	do
-	{
-		const Point &pt = paroi1.m_vMeasure [dwPoint];
-
-		fInGfx = PointInBuffer (pt);
-		if (fInGfx)
-		{
-			unsigned char bLevel = GetIntensity (pt);
-
-			m_bBuffer [dwPoint] = bLevel;
-			if (bLevel < dwSeek)
-				dwPoint++;
-			else if (bLevel > dwMax)
-	            // la valeur trouv�e d�passe la valeur du sommet de la pente de la paroi
-		        // du bas, on consid�re que c'est une erreur
-			    fInGfx = false;
-			else
-			{
-				long dwPos = dwPoint;
-
-				// il est tr�s peu probable que l'on arrive juste sur le milieu de la pente.
-				// on cherche donc les extr�mes.
-            
-				// recherche du bas de la pente
-				while (dwPoint && (m_bBuffer [dwPoint - 1] <= m_bBuffer [dwPoint]))
-					dwPoint--;
-				paroi1.m_slope [1].m_dwPos [0] = dwPoint;
-            
-				// recherche du sommet de la pente
-				dwPoint = dwPos + 1;
-				paroi1.m_slope [1].m_dwPos [1] = 0; // normalement d�j� fait
-				while (!paroi1.m_slope [1].m_dwPos [1])
-				{
-					const Point &pt = paroi1.m_vMeasure [dwPoint];
-
-					if (!PointInBuffer (pt))
-						paroi1.m_slope [1].m_dwPos [1] = dwPoint - 1;
-					else
-					{
-						m_bBuffer [dwPoint] = GetIntensity (pt);
-						if (m_bBuffer [dwPoint] > m_bBuffer [dwPoint - 1])
-							dwPoint++;
-						else
-							paroi1.m_slope [1].m_dwPos [1] = dwPoint - 1;
-					}
-				}
-				// la 1� pente est ignor�e par cette m�thode, seule la 2� pente est analys�e
-				SetMiddlePoint (paroi1.m_slope [1], paroi1.m_vMeasure);
-				fFound = true;
-			}
-		}
-	} while (fInGfx && !fFound);
-
-	return (fFound);
-} // end of FindOpposite
-
-/*----------------------------------------------------------\
-|                   SetMiddlePoints                         |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|    D�termine la position des deux points encadrants le    |
-|  milieu d'une des deux pentes.                            |
-|    Les deux points retourn�s peuvent �tre confondus.      |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  slope    : pente sur laquelle effectuer les mesures      |
-|  vMeasure : vecteur sur lequel cette pente a �t� d�tect�e |
-\----------------------------------------------------------*/
-void CEIMBase::SetMiddlePoint(
-	sSlope  &slope,
-	CVector &vMeasure,
-	bool reverseSlope)
-{
-	int   iMean;
-	long dwPos;
-
-	// on utilise le double du milieu, car 80+21/2=50, pas 50.5 puisque c'est un entier
-	//assert (AfxIsValidAddress (&slope, sizeof (slope)));
-
-//	[JAK - 06/09/02]  l'assert surgit un peu trop souvent lors de mesure de la distensibilit�   
-//	if ( reverseSlope )
-//		ASSERT (m_bBuffer[slope.m_dwPos[0]] > m_bBuffer [slope.m_dwPos[1]]);//ICI
-//	else
-//		ASSERT (m_bBuffer[slope.m_dwPos[0]] < m_bBuffer [slope.m_dwPos[1]]);
-	
-	dwPos = slope.m_dwPos[0];
-	iMean = m_bBuffer [dwPos] + m_bBuffer [slope.m_dwPos [1]];
-
-	if (reverseSlope)
-		while (m_bBuffer [dwPos] * 2 > iMean)  dwPos++;
-	else
-		while (m_bBuffer [dwPos] * 2 < iMean)  dwPos++;
-
-	// La mesure d'EIM est maintenant faite ici, car les intensit�s des points sont
-	// n�cessaires pour estimer la position exacte du milieu (en INTENSITE)
-	if (m_bBuffer [dwPos] * 2 == iMean)
-	{
-		// en cas d'�galit�, les deux points sont confondus
-		slope.m_ptDraw    = 
-		slope.m_ptMiddle  = vMeasure [dwPos];
-		slope.m_dblMiddle = 0.0;
-	}
-	else
-	{
-		dwPos--;
-		slope.m_ptMiddle = vMeasure [dwPos];
-
-		if ( reverseSlope )
-		{
-			if (iMean - 2 * m_bBuffer [dwPos + 1] < 2 * m_bBuffer [dwPos] - iMean)
-			  slope.m_ptDraw = slope.m_ptMiddle;
-			else
-			  slope.m_ptDraw = vMeasure [dwPos + 1];
-	//  [JAK - 3/8/2002]		ASSERT (m_bBuffer [dwPos + 1] < m_bBuffer [dwPos]);
-		}
-		else
-		{
-			if (2 * m_bBuffer [dwPos + 1] - iMean > iMean - 2 * m_bBuffer [dwPos])
-				slope.m_ptDraw = slope.m_ptMiddle;
-			else
-				slope.m_ptDraw = vMeasure [dwPos + 1];
-			//assert (m_bBuffer [dwPos + 1] > m_bBuffer [dwPos]);
-		}//
-	
-		assert (abs (slope.m_ptMiddle.x - vMeasure [dwPos + 1].x) <= 1);
-		assert (abs (slope.m_ptMiddle.y - vMeasure [dwPos + 1].y) <= 1);
-		slope.m_dblMiddle =
-			  (  double (iMean - m_bBuffer [dwPos] * 2)
-			   * CVector (slope.m_ptMiddle, vMeasure [dwPos + 1]).Norm ()
-			   / (m_bBuffer [dwPos + 1] - m_bBuffer [dwPos]) // bug potentiel : division par zero [JAK - 15/10/2002]
-			   / 2
-			  );
-	}
-	// permet un affichage beaucoup plus rapide de l'histogramme
-	slope.m_dwMiddle    = dwPos;
-	slope.m_dwIntensity = iMean / 2;
-} // fin de SetMiddlePoints
-
-/*----------------------------------------------------------\
-|                 CEIM::MeasureLineBuffer                   |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Mesure de l'E.I.M. � partir d'un buffer d'intensit� et   |
-|     de variation                                          |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  paroi       : Info � d�finir sur la mesure d'EIM         |
-|  pbIntensity : pointeur sur les intensit�s                |
-|  pcOffsets   : pointeur sur les variations d'intensit�    |
-|  dwPoints    : nombre de points � �tudier                 |
-|-----------------------------------------------------------|
-| RETOUR :                                                  |
-|  un bool�en indiquant si le profil a �t� reconnu          |
-\----------------------------------------------------------*/
-int CEIMBase::MeasureLineBuffer
-(
-	sParoi   &paroi,
-	unsigned char*    pbBuffer,
-	char     *pcOffsets,
-	long     dwPoints
-)
-{
-	m_diag = 0; // Permet de voir o� l'algorithme s'est arr�t� (afin de l'am�liorer)
-					// Valeur n�gative 
-
-	if (dwPoints < 3)
-	{
-		return (0);
-	}
-	else
-	{
-		long dwStart, dwPos, dwFirst, dwLast, dwLastChanged;
-		bool  fChanged;
-
-		/////////////////////////////////
-		// lissage de la courbe de densit�
-		/////////////////////////////////
-
-		// il ne faut pas corriger les ext�rieurs sinon, � cause du report,
-		// tous les points seront corrig�s
-		// sur 300 points le lissage dure moins d'une milliseconde
-		dwFirst = 2;
-		dwLastChanged = dwLast  = dwPoints - 2;
-		do
-		{
-			char c, c1, c2, c3;
-
-			fChanged = false;
-
-			// on ne prend pas en compte les variations nulles, autrement dit
-			// un 1,1,0,-1,1 ->1,1,0,1(ou 0),1.
-			// ainsi les variations de 1 pixel sont ignor�es
-			// on conserve donc en m�moire le dernier point significatif (au d�but 0...)
-			c1 = pcOffsets [dwFirst - 1];
-			for (dwPos = dwFirst; dwPos < dwLast; dwPos++)
-			{
-				c  = pcOffsets [dwPos - 1];
-				if (c) // non nul
-					c1 = c;  // nouvelle variation
-				c2 = pcOffsets [dwPos    ];
-				c3 = pcOffsets [dwPos + 1];
-				// on met � jour le pt central � jour si les deux extr�mes varient dans le m�me sens
-				//    et que le point central varie dans le sens inverse.
-				if ((c1 == c3) && (c2 != c1))
-				{
-					pbBuffer  [dwPos    ] = (unsigned char )((pbBuffer  [dwPos - 1] + pbBuffer [dwPos + 1]) / 2);
-					// on est oblig� de recalculer les variations
-					pcOffsets [dwPos    ] = Delta (m_bBuffer [dwPos    ], m_bBuffer [dwPos - 1]);
-					pcOffsets [dwPos + 1] = Delta (m_bBuffer [dwPos + 1], m_bBuffer [dwPos    ]);
-					// ce test n'est pas la pour le FUN !! si l'�cart entre deux intensit� est 1
-					// le milieu sera le point de plus faible intensit�, ce qui ne changera rien
-					if ((pcOffsets [dwPos] != c2) || (pcOffsets [dwPos + 1] != c3))
-					{
-						if (!fChanged)
-						{
-							fChanged = true;
-							dwFirst  = dwPos;
-						}
-						// d�s que fChanged est VRAI il faut initialiser dwLastChanged (petit oubli !!)
-						dwLastChanged = dwPos; // si on change dwLast, on quitte la boucle!!
-					}
-				}
-			}
-
-			dwLast = dwLastChanged;
-		} while (fChanged);
-
-		////////////////////////////////////
-		// recherche du profil de densit� //
-		////////////////////////////////////
-
-		// pour un algo avec gestion de seuils voir fichier EIM/AvecSeuil.cpp
-		// a) recherche d'une croissance (3 pixels de suite au moins : 2 variations de m�me sens)
-		//    � partir du pixel donn�, pour un maximum de points donn�
-		// le premier est le plus complexe � trouver.
-#ifdef TEST_FOR_FANTOME
-		dwStart = 2;
-#endif
-		if ( LookForFirstPoint (dwStart, dwPoints, dwPos, m_bBuffer) )
-		{
-			m_diag = -1; 
-
-			paroi.m_slope [0].m_dwPos [0] = dwPos; // sera modifi� si le delta est insuffisant
-			// b) recherche d'une d�croissance (3 pixels de suite au moins : 2 variations de m�me sens)
-			bool variation = LookForVariation (dwStart, pcOffsets, dwPoints, enumDown, dwPos);
-#ifdef TEST_FOR_FANTOME
-			if ( !variation )
-			{
-				if ( LookForFirstPoint (dwStart, dwPoints, dwPos, m_bBuffer) )
-				{
-					variation = LookForVariation (dwStart, pcOffsets, dwPoints, enumDown, dwPos);
-				}
-			}
-#endif
-			if ( variation )
-			{
-				m_diag = -2; 
-	
-				paroi.m_slope [0].m_dwPos [1] = dwPos;
-				paroi.m_slope [2].m_dwPos [0] = dwPos; // Pour INT 
-				// "g�n�ration" de plateaux. Suppression des petites irr�gularit�s sur des plateaux,
-				//                           afin de d�tecter ais�ment les zones de saturation
-				// ce n'est n�cessaire qu'� ce niveau
-				for (dwFirst = dwPos; dwFirst < dwPoints - 3; dwFirst++)
-				{
-					unsigned char b = pbBuffer [dwFirst];
-
-					// il faut �galement mettre � jour pcOffsets, sinon on engendre une incoh�rence
-					if ( (b == pbBuffer [dwFirst + 2])
-					&& (abs (b - pbBuffer [dwFirst + 1]) < 5))
-					{
-						pbBuffer  [dwFirst + 1] = b;
-						pcOffsets [dwFirst + 1] = 0;
-					}
-					else if (   (b == pbBuffer [dwFirst + 3])
-					&& (abs (b - pbBuffer [dwFirst + 1]) < 5)
-					&& (abs (b - pbBuffer [dwFirst + 2]) < 5))
-					{
-						pbBuffer  [dwFirst + 1] = b;
-						pbBuffer  [dwFirst + 2] = b;
-						pcOffsets [dwFirst + 1] = 0;
-						pcOffsets [dwFirst + 2] = 0;
-					}
-	
-				}
-
-				// c) recherche d'une croissance (3 pixels de suite au moins : 2 variations de m�me sens)
-				if (LookForVariation (dwStart, pcOffsets, dwPoints, enumUp, dwPos))
-				{
-					m_diag = -3; 
-					if (pbBuffer [paroi.m_slope [0].m_dwPos [1]] <= m_bDelta2 + pbBuffer [dwStart - 1])
-					{
-						m_diag = -4; 
-						// Test Ajout test 1 180808
-						if ((m_versionTomtecAout08 && ((2 * pbBuffer [dwStart - 1])> m_bSeuil1)) || (!m_versionTomtecAout08))
-						{
-//							if ((2 * pbBuffer [dwStart - 1])> (2 * pbBuffer [paroi.m_slope [0].m_dwPos [1]]))
-							{
-								paroi.m_slope[1].m_dwPos[0] = dwPos;
-								paroi.m_slope[1].m_dwPos[1] = dwStart - 1;
-								paroi.m_slope[2].m_dwPos[1] = dwPos;
-							}
-							return (1);
-						}
-					}
-					if (m_versionTomtecAout08)
-					{
-
-						dwStart += 3; 
-						// On fait 2 fois de suite la recherche d'une croissance 180808
-						// La premi�re croissance peut �tre une erreur
-						// d) recherche d'une seconde croissance (3 pixels de suite au moins : 2 variations de m�me sens)
-						if (LookForVariation (dwStart, pcOffsets, dwPoints, enumUp, dwPos))
-						{
-							m_diag = -5; 
-							if (pbBuffer [paroi.m_slope [0].m_dwPos [1]] <= m_bDelta2 + pbBuffer [dwStart - 1])
-							{
-								m_diag = -6; 
-								// Test Ajout test 1 180808
-								if ((2 * pbBuffer [dwStart - 1])> m_bSeuil1) 
-								{
-			//							if ((2 * pbBuffer [dwStart - 1])> (2 * pbBuffer [paroi.m_slope [0].m_dwPos [1]]))
-									{
-										paroi.m_slope[1].m_dwPos[0] = dwPos;
-										paroi.m_slope[1].m_dwPos[1] = dwStart - 1;
-										paroi.m_slope[2].m_dwPos[1] = dwPos;
-									}
-									return (1);
-								}
-							}		
-						}
-					}
-/*
-					// d) recherche d'une d�croissance (3 pixels de suite au moins : 2 variations de m�me sens)
-					//    il faut que le maximal de la deuxi�me pente soit plus haut que le maximal de la premi�re
-					//    (c'est un crit�re tr�s efficace pour �liminer de mauvaise mesures, en g�n�ral lorsque la
-					//     "1�" paroi qui a �t� d�tect�e n'est pas la bonne)
-					if (LookForVariation (dwStart, pcOffsets, dwPoints, enumDown, dwPos))
-					{
-						// on cherche le d�but du plateau si on est dessus, le dernier point doit �tre la fin
-						// d'une croissance STRICTE
-						dwFirst = dwPos; // on veut conna�tre la taille du plateau
-						while (pbBuffer [dwPos] == pbBuffer [dwPos - 1])
-							dwPos--;
-
-						if (   (pbBuffer [paroi.m_dwPos [1]] + m_bDelta2 < pbBuffer [dwPos])
-						|| ((dwFirst - dwPos >= 2) && (pbBuffer [dwPos] >= 240))
-						)
-						{
-							paroi.m_dwPos[3] = dwPos;
-							return (1);
-						}
-					}
-*/
-				}
-			}
-		}
-	}
-
-	return (0);
-} // end of Measure
-
-/*----------------------------------------------------------\
-|                 LookForFirstPoint                         |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Recherche du premier point caract�ristique de la paroi   |
-|  Il m�rite � lui seul une fonction...                     |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  dwStart  : premier point � examine                       |
-|  dwMax    : dernier point examinable                      |
-|  dwPos    : o� stocker la position trouv�e                |
-|  pbBuffer : ligne d'intensit�                             |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un bool�en indiquant si la variation recherch�e a �t�    |
-|  trouv�e                                                  |
-\----------------------------------------------------------*/
-bool CEIMBase::LookForFirstPoint
-(	long   &dwStart,
-	long    dwMax,
-	long   &dwPos,
-	unsigned char*   pbBuffer
-)
-{
-	// r�gles de d�tection de la premi�re pente:
-	//   1. trois points doivent se se suivre avec une intensit� croissante
-	//   2. le dernier des points, doit avoir une intensit� �gal � m_bDelta1 + la moyenne des pr�c�dents
-	//   3. au moins trois points cons�cutifs doivent ensuite avoir une intensit� inf�rieur au premier sommet
-	//
-	// l'intensit� du premier point sert de rep�re
-
-	unsigned char   bFirst = pbBuffer [1]; // intensit� du premier point
-	unsigned char* pb;
-
-#ifndef TEST_FOR_FANTOME
-	dwStart = 2; // on commence � 2 pour avoir acc�s � -1 et -2
-#endif
-	pb = &pbBuffer [dwStart];
-	while ( (dwStart < dwMax) &&
-            ( ( ( pb [ 0] - bFirst ) < m_bDelta1) // tant que le point courant n'est pas assez lumineux, on continue
-             || ( pb [-2] >= pb [-1] ) ) )
-	{
-		pb++, dwStart++;
-	}
-
-	if (dwStart >= dwMax)
-	{
-		return (false);
-	}
-	else
-	{
-		dwPos = dwStart - 1;
-		// on incr�mente dwStart jusqu'� une d�croissance STRICTE double
-		// une simple d�croissance est une irr�gularit� � ignorer
-		while ((dwStart < dwMax) && ((pb [1] >= pb [0]) || (pb [2] >= pb [0])))
-		{
-			pb++, dwStart++;
-		}
-
-		dwStart++; // il faut que l'on pointe sur le d�but de la d�croissance
-      
-		if (dwStart >= dwMax)
-		{
-			return (false);
-		}
-		else
-		{
-			pb = &pbBuffer [dwPos];
-
-			// on cherche le premier point � m_bDelta1 du sommet
-			// on est certain de trouver un point (au pire dwStart)
-			// bFirst = BYTE (pbBuffer [dwStart - 1] - m_bDelta1);  // dwStart pointe juste apr�s le sommet
-			// while (bFirst < pb [0]) // comparaison STRICTE
-			// pb--, dwPos--;
-			// on continue tant qu'il y a une d�croissance STRICTE (on autorise UNE irr�gularit� m�me apr�s lissage)
-			// sinon si que du noir, on arrive au d�but du segment!!
-			// le test sur m_bDelta1 emp�che fr�quemment la d�tection r�elle du d�but de la pente
-			while (dwPos && ((pb[0] > pb[-1]) || ((dwPos > 1) && (pb[0] > pb[-2]))))
-			{
-				pb--, dwPos--;
-			}
-
-			return (true);
-		}
-	}
-} // fin de LookForFirstPoint
-
-/*----------------------------------------------------------\
-|               CEIM::LookForVariation                      |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Recherche dans le buffer une variation de densit� dans le|
-|     sens donn�, et d�place le pointeur tant que cette     |
-|     variation est maintenue                               |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  dwStart : premier point � examine                        |
-|  pcOffsets : tableau de variation de densit�s             |
-|  dwMax     : dernier point examinable                     |
-|  dir       : sens de variation recherch�                  |
-|  dwPos     : o� stocker la position trouv�e               |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un bool�en indiquant si la variation recherch�e a �t�    |
-|  trouv�e                                                  |
-\----------------------------------------------------------*/
-bool CEIMBase::LookForVariation (long &dwStart, char *pcOffsets, long dwMax, enumDirection dir, long &dwPos)
-{
-	char c1, c2;
-
-	assert (dwStart); // le tableau de variation d�bute � 1
-	while (dwStart < dwMax)
-	{
-		c1 = pcOffsets [dwStart];
-		c2 = pcOffsets [dwStart + 1];
-		if (c1 && (c1 == c2)) // il faut une variation (c1 != 0) <=> (c2 != 0)
-		{
-			if (dir == enumUp)
-			{
-				if (c1 < 0)
-				{
-					return (false); // Sens inverse de celui recherch�
-				}
-				else
-				{
-					dwPos = dwStart - 1;
-					dwStart++;
-					do
-					{
-						dwStart++;
-						// } while ((dwStart < dwMax) && (pcOffsets [dwStart] >= 0));
-					} while ((dwStart < dwMax) && (pcOffsets [dwStart] > 0));
-
-					return (true);
-				}
-			}
-			else
-			{
-				if (c1 > 0)
-				{
-					return (false); // croissance, au lieu de d�croissance
-				}
-				else
-				{
-					dwPos = dwStart - 1;
-					dwStart++;
-					do
-					{
-						dwStart++;
-					} while ((dwStart < dwMax) && (pcOffsets [dwStart] <= 0));
-
-					return (true);
-				}
-			}
-		}
-		dwStart++;
-	}
-
-	return (false);
-} // fin de LookForVariation
-
-/*----------------------------------------------------------\
-|                     Update                                |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Mesures des parois reconnues et statistiques             |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  VRAI si au moins un profil a �t� reconnu                 |
-\----------------------------------------------------------*/
-bool CEIMBase::Update (CEIMResult *m_res)
-{
-	// ATTENTION, il se peut qu'aucun profil n'ait �t� d�tect�
-	//  [JAK - 24/6/2002]  no histogram window
-	//initialisation
-	GraphMeanInit();
-	m_arVariance.clear();
-	m_arVarianceAA.clear();
-	m_arVarianceII.clear();
-	m_arVarianceINT.clear();
-	m_dwValidPoints = 0;
-	m_dblDistance  = 0.0;
-	m_dblEIMMin    =
-	m_dblEIMMean   =
-	m_dblEIMMax    =
-	m_dblINTMin    =
-	m_dblINTMean   =
-	m_dblINTMax    =
-	m_dblEIMdMean  =
-	m_dblINTdMean  =
-	m_dblMEDdMean  =
-	m_dblIAd       =
-	m_dblDiaAAMin  =
-	m_dblDiaAAMean =
-	m_dblDiaAAMax  =
-	m_dblDiaIIMin  =
-	m_dblDiaIIMean =
-	m_dblDiaIIMax  = 0.0;
-	
-	if (m_pMeasures == NULL)
-		return (false);
-	else
-	{
-		CEIMInfo *pInfo = &m_pMeasures [0];
-		long     dw;
-		double    dblMeanEIM,   // valeur moyenne de l'EIM lors de la 1� phase
-			dblMeanINT,
-			dblMeanEIMd,
-			dblMeanINTd,
-			dblMeanMEDd,
-			dblGapEIM,
-			dblMeanQI,
-			dblMeanDia,   // valeur moyenne du diam�tre lors de la 1� phase
-			dblGapDia,
-			dblMeanDist,  // distance moyenne du 1� milieu au trait utilisateur
-			dblStdDist,
-			dblGapDist,
-			dblII;        // diam�tre intima/intima
-		 //   dblGapQI;
-		// la premi�re �tape consiste:
-		// - � calculer la valeur de l'EIM � partir des points d�tect�s
-		// - � calculer la moyenne des mesures afin d'�liminer ensuite
-		//       celles qui s'�cartent trop de cette valeur moyenne.
-		dblGapEIM = 0;
-		dblGapDist = 0;
-		dblGapDia = 0;
-		dblII = 0;
-		dblMeanEIM  = 0;
-		dblMeanINT  = 0;
-		dblMeanEIMd = 0;
-		dblMeanINTd = 0;
-		dblMeanMEDd = 0;
-		dblMeanDia  = 0;
-		dblMeanDist = 0;
-		dblStdDist = 0.0;
-		dblMeanQI = 0.0;
-		
-		for (dw = 0; dw < m_dwPoints; dw++)
-		{
-			if (pInfo->m_fValid) // le profil a �t� rep�r�
-			{
-				dblMeanEIM  += pInfo->m_dblEIM;
-				dblMeanINT  += pInfo->m_dblINT;//PJT
-				dblMeanEIMd += pInfo->m_dblEIMd;
-				dblMeanINTd += pInfo->m_dblINTd;
-				dblMeanMEDd += pInfo->m_dblMEDd;
-				dblMeanDia  += pInfo->m_dblDia;
-				dblMeanDist += pInfo->m_dblDist;
-				dblStdDist  += pInfo->m_dblDist * pInfo->m_dblDist;
-				dblMeanQI += pInfo->m_dblQI;
-				m_dwValidPoints++; // requis pour obtenir la moyenne
-			}
-			pInfo++;
-		}
-		if (m_dwValidPoints == 0)
-		{
-			m_uErrorID = IDS_EIM_FAILED;//BUG ICI  //[JAK - 09/09/02]
-			return (false);   // aucune mesure valide
-		}
-		else
-		{
-			try//  [JAK - 5/7/2002]
-			{				
-				// calcul des moyennes
-				dblMeanEIM  /= m_dwValidPoints;
-				dblMeanDia  /= m_dwValidPoints;
-				dblMeanDist /= m_dwValidPoints;
-				dblStdDist  /= m_dwValidPoints;
-				dblMeanINT  /= m_dwValidPoints;//PJT
-				dblMeanEIMd /= m_dwValidPoints;
-				dblMeanINTd /= m_dwValidPoints;
-				dblMeanMEDd /= m_dwValidPoints;
-				dblMeanQI /= m_dwValidPoints;
-				
-				// l'�cart autoris� est �gal � 25% de la moyenne	23/02/99 Touboul
-				// l'�cart autoris� est �gal � 50% de la moyenne	06/05/99 Touboul
-				// l'�cart autoris� est �gal � 35% de la moyenne	19/07/99 Touboul
-				// l'�cart autoris� est �gal � 10% de la moyenne	19/07/05 Touboul
-				if (m_versionTomtecAout08)
-				{
-					dblGapEIM = dblMeanEIM *.25;//.35  20/10/05 PJT // 0.2 180808
-					dblGapDia = dblMeanDia *.02;//.04  20/10/05 PJT
-					dblGapDist = dblMeanDist *.15;//.25  20/10/05 PJT // 0.2 180808
-				}
-				else
-				{
-					dblGapEIM = dblMeanEIM *.20;
-					dblGapDia = dblMeanDia *.02;
-					dblGapDist = dblMeanDist *.20;
-				}
- 
-//				dblGapDist = sqrt(dblStdDist - dblMeanDist * dblMeanDist);//  20/12/06 FP
-				pInfo = &m_pMeasures[0];
-				// exclusion de tous les points hors normes
-				for (dw = 0; dw < m_dwPoints; dw++)
-				{
-					if (   pInfo->m_fValid
-						// on exclut tous les point qui s'�cartent trop de la moyenne
-						&& (   (fabs (pInfo->m_dblEIM  - dblMeanEIM ) > dblGapEIM)                 // EIM incoh�rent
-						|| (fabs (pInfo->m_dblDist - dblMeanDist) > dblGapDist)                // ou distance � l'axe incoh�rente
-						|| (m_fDiameter && (fabs (pInfo->m_dblDia - dblMeanDia) > dblGapDia))  // ou diam�tre incoh�rent
-						|| (fabs (pInfo->m_dblQI)> 0.3) // IQ < 50% Touboul
-						)
-						)
-					{
-						pInfo->m_fThrownOut = true; // par d�faut � FALSE gr�ce au memset (on laisse valide pour affichage palette)
-						pInfo->m_fValid     = false;
-						m_dwValidPoints--;
-					}
-					pInfo++;
-				}
-				// il se peut que TOUS les points soient � + de 20% de la moyenne
-				// (par exemple deux lignes tr�s �loign�es)
-				if (m_dwValidPoints == 0)
-				{
-					m_uErrorID = IDS_EIM_FAILED;
-					return (false);   // aucune mesure valide
-				}
-				else
-				{
-					if (m_fDiameter) // Calcul de la moyenne des diam�tres trouv�s
-					{
-						std::vector<double> arrayAA, arrayII;//il s'agit en faite d'une duplication de m_arVarianceAA et m_arVarianceII
-						double dblMeanAA = 0.0;
-						double dblMeanII = 0.0;
-						double dblVarianceAA = 0.0;
-						double dblVarianceII = 0.0;
-						
-						// recherche du premier profil valide
-						pInfo = &m_pMeasures [0];
-						for (dw = 0; !pInfo->m_fValid; dw++)
-						{
-							pInfo++;
-						}
-						// on est certain qu'un pInfo valide va �tre trouv�
-
-						//----- resultat d'un calcul de diametre  [JAK - 13/1/2003]
-						m_dblDiaAAMin = m_dblDiaAAMean = m_dblDiaAAMax = pInfo->m_dblDia; 
-						m_dblDiaIIMin = m_dblDiaIIMean = m_dblDiaIIMax = pInfo->m_dblDia - 2 * pInfo->m_dblEIM;
-                       
-						arrayII.push_back(g_pCurrentScale->Distance(m_dblDiaIIMean));						
-						arrayAA.push_back(g_pCurrentScale->Distance(m_dblDiaAAMean));												
-
-						GraphMeanAddMeasure(true, pInfo->m_dblDia);
-						
-						m_arVarianceAA.push_back (g_pCurrentScale->Distance (pInfo->m_dblDia));
-						m_arVarianceII.push_back (g_pCurrentScale->Distance (pInfo->m_dblDia- 2 * pInfo->m_dblEIM));
-						dblMeanAA = g_pCurrentScale->Distance (pInfo->m_dblDia);
-						dblMeanII = g_pCurrentScale->Distance (pInfo->m_dblDia - 2 * pInfo->m_dblEIM);
-						
-						dw++,pInfo++;
-						
-						while (dw < m_dwPoints)
-						{
-							if (pInfo->m_fValid)
-							{
-								m_dblDiaAAMean += pInfo->m_dblDia;
-								if (pInfo->m_dblDia < m_dblDiaAAMin) m_dblDiaAAMin = pInfo->m_dblDia;
-								if (pInfo->m_dblDia > m_dblDiaAAMax) m_dblDiaAAMax = pInfo->m_dblDia;
-								dblII = pInfo->m_dblDia - 2 * pInfo->m_dblEIM;
-								
-								m_dblDiaIIMean += dblII; 
-								if (dblII < m_dblDiaIIMin) m_dblDiaIIMin = dblII;
-								if (dblII > m_dblDiaIIMax) m_dblDiaIIMax = dblII;
-								
-								//  [JAK - 24/6/2002]  no histogram window      
-								GraphMeanAddMeasure (true, pInfo->m_dblDia);
-
-								arrayAA.push_back(g_pCurrentScale->Distance(pInfo->m_dblDia));						
-								arrayII.push_back(g_pCurrentScale->Distance(dblII));				
-								m_arVarianceAA.push_back (g_pCurrentScale->Distance (pInfo->m_dblDia));
-								m_arVarianceII.push_back (g_pCurrentScale->Distance (dblII));
-								
-								dblMeanAA += g_pCurrentScale->Distance (pInfo->m_dblDia);
-								dblMeanII += g_pCurrentScale->Distance (dblII);
-							}
-							dw++;
-							pInfo++;
-						}
-
-						/* if (m_vUser.Length () < QI_MIN)
-						{
-						CString msg; msg.Format(MyLoadString(IDS_EIM_QI_0), QI_MIN);
-						CMessage::Info (msg);
-						m_dblQI = 0.;
-						}
-						else*/
-						m_dblQI = double (m_dwValidPoints) / m_dwPoints;
-						
-						// calcul de la variance
-						dblMeanAA /= (double)m_arVarianceAA.size ();
-						dblMeanII /= (double)m_arVarianceII.size ();
-						dblVarianceAA = 0.0;
-						dblVarianceII = 0.0;
-						for (unsigned int i = 0; i < m_arVarianceAA.size (); i++)
-						{
-							dblVarianceAA += (m_arVarianceAA [i] - dblMeanAA) * (m_arVarianceAA [i] - dblMeanAA);
-							dblVarianceII += (m_arVarianceII [i] - dblMeanII) * (m_arVarianceII [i] - dblMeanII);			
-						}
-						
-						dblVarianceAA /= (double)m_arVarianceAA.size ();
-						dblVarianceII /= (double)m_arVarianceII.size ();
-						m_dblDistance = m_vUser.Norm (g_pCurrentScale);
-						
-						m_dblDiaAAMean /= (double)m_dwValidPoints;
-						m_dblDiaIIMean /= (double)m_dwValidPoints;
-						m_dblDiaAAMin  = g_pCurrentScale->Distance (m_dblDiaAAMin);
-						m_dblDiaAAMean = g_pCurrentScale->Distance (m_dblDiaAAMean);
-						m_dblDiaAAMax  = g_pCurrentScale->Distance (m_dblDiaAAMax);
-						m_dblDiaIIMin  = g_pCurrentScale->Distance (m_dblDiaIIMin);
-						m_dblDiaIIMean = g_pCurrentScale->Distance (m_dblDiaIIMean);
-						m_dblDiaIIMax  = g_pCurrentScale->Distance (m_dblDiaIIMax);
-
-						assert(arrayAA.size() == (size_t)m_dwValidPoints);
-						assert(arrayII.size() == (size_t)m_dwValidPoints);
-
-//						double diam = CMeanEstimate::GetMeanEstimate(&arrayAA);
-//						m_dblDiaAAMean = (CMeanEstimate::IsANumber(diam)? diam : -1); 
-
-						m_dblDiaAAMean = CMeanEstimate::GetMeanEstimate(&arrayAA); 
-						m_dblDiaIIMean = CMeanEstimate::GetMeanEstimate(&arrayII);
-						m_dblVarianceAA = dblVarianceAA; 
-						m_dblVarianceII = dblVarianceII; 
-						PrintDiameter();
-
-						if (!CMeanEstimate::IsANumber(m_dblDiaAAMean))
-						{ //if is is infinite because of the estimate
-							return false;
-						}
-
-					}
-					else  // de l'EIM  
-					{
-						double dblMean = 0.0, dblMeanINT = 0.0;
-					//	double dblMeanEIMd = 0.0, dblMeanINTd = 0.0, dblMeanMEDd = 0.0;
-						double dblVariance = 0.0, dblVarianceINT = 0.0;
-						imt::Point invalidPoint, tmpPt;
-
-						invalidPoint.x = -1;
-						invalidPoint.y = -1;
-						
-						if ( m_res )
-						{
-							m_res->result->numberOfPoints = m_dwPoints;
-							m_res->allocate_vectors( m_dwPoints );
-						}
-						
-						// recherche du premier profil valide
-						pInfo = &m_pMeasures [0];
-						for (dw = 0; !pInfo->m_fValid; dw++)
-						{
-							if ( m_res )
-							{
-								m_res->result->vect_adventitia[dw] = invalidPoint;
-								m_res->result->vect_media[dw] = invalidPoint;
-								m_res->result->vect_intima[dw] = invalidPoint;
-							}
-							pInfo++;
-						}
-						// on est certain qu'un pInfo valide va �tre trouv�
-						m_dblEIMMin   = m_dblEIMMean   = m_dblEIMMax   = pInfo->m_dblEIM;
-						m_dblINTMin   = m_dblINTMean   = m_dblINTMax   = pInfo->m_dblINT;
-						m_dblEIMdMean = pInfo->m_dblEIMd;
-						m_dblINTdMean = pInfo->m_dblINTd;
-						m_dblMEDdMean = pInfo->m_dblMEDd;
-						
-						//  [JAK - 24/6/2002]  no histogram window
-						GraphMeanAddMeasure (true, pInfo->m_dblEIM);
-						m_arVariance.push_back (g_pCurrentScale->Distance (pInfo->m_dblEIM));
-						m_arVarianceINT.push_back (g_pCurrentScale->Distance (pInfo->m_dblINT));
-						dblMean = g_pCurrentScale->Distance (pInfo->m_dblEIM);
-						dblMeanINT = g_pCurrentScale->Distance (pInfo->m_dblINT);
-						
-						if ( m_res )
-						{
-							tmpPt.x = pInfo->m_Paroi[0].m_slope[1].m_ptDraw.x;
-							tmpPt.y = pInfo->m_Paroi[0].m_slope[1].m_ptDraw.y;
-							m_res->result->vect_adventitia[dw] = tmpPt;
-							tmpPt.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-							tmpPt.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-							m_res->result->vect_media[dw] = tmpPt;
-							tmpPt.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-							tmpPt.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-							m_res->result->vect_intima[dw] = tmpPt;
-						}
-						
-						dw++,pInfo++;
-						
-						while (dw < m_dwPoints)
-						{
-							if (pInfo->m_fValid)
-							{
-								m_dblEIMMean += pInfo->m_dblEIM;
-								if (pInfo->m_dblEIM < m_dblEIMMin) m_dblEIMMin = pInfo->m_dblEIM;
-								if (pInfo->m_dblEIM > m_dblEIMMax) m_dblEIMMax = pInfo->m_dblEIM;
-								
-								m_dblINTMean += pInfo->m_dblINT;
-								if (pInfo->m_dblINT < m_dblINTMin) m_dblINTMin = pInfo->m_dblINT;
-								if (pInfo->m_dblINT > m_dblINTMax) m_dblINTMax = pInfo->m_dblINT;
-								
-								m_dblEIMdMean += pInfo->m_dblEIMd;
-								m_dblINTdMean += pInfo->m_dblINTd;
-								m_dblMEDdMean += pInfo->m_dblMEDd;
-								
-								//  [JAK - 24/6/2002]  no histogram window
-								GraphMeanAddMeasure (true, pInfo->m_dblEIM);
-								m_arVariance.push_back (g_pCurrentScale->Distance (pInfo->m_dblEIM));
-								m_arVarianceINT.push_back (g_pCurrentScale->Distance (pInfo->m_dblINT));
-								dblMean += g_pCurrentScale->Distance (pInfo->m_dblEIM);
-								dblMeanINT += g_pCurrentScale->Distance (pInfo->m_dblINT);
-								
-								if ( m_res )
-								{
-									tmpPt.x = pInfo->m_Paroi[0].m_slope[1].m_ptDraw.x;
-									tmpPt.y = pInfo->m_Paroi[0].m_slope[1].m_ptDraw.y;
-									m_res->result->vect_adventitia[dw] = tmpPt;
-									tmpPt.x = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.x;
-									tmpPt.y = pInfo->m_Paroi[0].m_slope[2].m_ptDraw.y;
-							          	m_res->result->vect_media[dw] = tmpPt;
-									tmpPt.x = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x;
-									tmpPt.y = pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y;
-							          	m_res->result->vect_intima[dw] = tmpPt;
-								}
-							}
-							else
-							{
-								if ( m_res )
-								{
-									m_res->result->vect_adventitia[dw] = invalidPoint;
-									m_res->result->vect_media[dw] = invalidPoint;
-									m_res->result->vect_intima[dw] = invalidPoint;
-								}
-							}
-
-							dw++;
-							pInfo++;
-						}
-
-						if (m_vUser.Length () < QI_MIN)
-						{
-							PrintErrorQIMin();
-							m_dblQI = 0.;
-						}
-						else
-						{
-							m_dblQI = double (m_dwValidPoints) / m_dwPoints;
-						}
-						
-						// calcul de la variance
-						dblMean /= (double)m_arVariance.size ();
-						dblVariance = 0.0;
-						dblMeanINT /= (double)m_arVarianceINT.size ();
-						dblVarianceINT = 0.0;
-						unsigned int i;
-						for (i = 0; i < m_arVariance.size (); i++)
-							dblVariance += (m_arVariance [i] - dblMean) * (m_arVariance [i] - dblMean);
-						dblVariance /= (double)m_arVariance.size ();
-						for (i = 0; i < m_arVarianceINT.size (); i++)
-							dblVarianceINT += (m_arVarianceINT [i] - dblMeanINT) * 
-							(m_arVarianceINT [i] - dblMeanINT);
-						dblVarianceINT /= (double)m_arVarianceINT.size ();
-						m_dblDistance = m_vUser.Norm (g_pCurrentScale);
-						// calcul des valeurs moyennes et mise � l'�chelle des normes
-						m_dblEIMMean   /= (double)m_dwValidPoints;
-						m_dblEIMMin    = g_pCurrentScale->Distance (m_dblEIMMin);
-						m_dblEIMMean   = g_pCurrentScale->Distance (m_dblEIMMean);
-						m_dblEIMMax    = g_pCurrentScale->Distance (m_dblEIMMax);
-						m_dblINTMean   /= (double)m_dwValidPoints;
-						m_dblINTMin    = g_pCurrentScale->Distance (m_dblINTMin);
-						m_dblINTMean   = g_pCurrentScale->Distance (m_dblINTMean);
-						m_dblINTMax    = g_pCurrentScale->Distance (m_dblINTMax);
-						m_dblIA = m_dblINTMean / m_dblEIMMean;
-						
-						m_dblEIMdMean /= (double)m_dwValidPoints;
-						m_dblINTdMean /= (double)m_dwValidPoints;
-						m_dblMEDdMean /= (double)m_dwValidPoints;
-						m_dblIAd = m_dblINTdMean / m_dblEIMdMean;
-						
-						//#ifdef VERSION_SHOW_VARIANCE //  [JAK - 17/6/2002] 
-						m_dblVariance = dblVariance;
-						//#endif
-						
-						//  [JAK - 4/7/2002] IDS_EIM_RESULT4 =	\tE .I.M.\nI.Q.:     \t%.2f\nMaximale : \t%.3f mm\nMoyenne : \t%.3f mm\nEcart Type : \t%.3f mm\nMesures Valides :\td%
-						PrintResult();
-							
-						if ( m_res )
-						{
-							m_res->result->imt_max = m_dblEIMMax;
-							m_res->result->imt_mean = m_dblEIMMean;
-							m_res->result->imt_standardDeviation = sqrt (dblVariance);
-							m_res->result->intima_mean = m_dblINTMean;
-							m_res->result->media_mean = m_dblEIMMean - m_dblINTMean;
-							m_res->result->qualityIndex = m_dblQI;
-						}
-         }
-		 return (true);
-         }
-		 }catch(...){ //  [JAK - 5/7/2002]
-			 assert(0);
-			 // not very clean to catch any exception, but it is at least efficient
-			 //TODO change the "catch(...)" for something more precise like "catch(Float Divide by Zero)"
-			 m_uErrorID = IDS_EIM_FAILED;
-			 return (false);   // aucune mesure valide			 
-		 }
-      }
-   }
-} // end of Update
-
-/*----------------------------------------------------------\
-|                  ComputeEIM                               |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  calcule l'�paisseur EIM et la distance au vecteur trac�  |
-|  par l'utilisateur � l'aide points d�tect�s               |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pInfo : une info sur un segment de paroi                 |
-\----------------------------------------------------------*/
-void CEIMBase::ComputeEIM (CEIMInfo *pInfo)
-{
-	pInfo->m_fValid   = true;
-
-	// en approximation, m_ptMiddle [0] suffit largement pour la distance, qui n'intervient
-	// dans la mesure que pour �carter les points trop �loign�s de la moyenne
-	pInfo->m_dblDist  = CVector (pInfo->m_Paroi [0].m_slope [0].m_ptMiddle, pInfo->m_Paroi [0].m_vMeasure [0]).Norm ();
-	pInfo->m_dblEIM   = CVector (pInfo->m_Paroi [0].m_slope [0].m_ptMiddle, pInfo->m_Paroi [0].m_slope [1].m_ptMiddle).Norm ()
-                        - pInfo->m_Paroi [0].m_slope [0].m_dblMiddle
-                        + pInfo->m_Paroi [0].m_slope [1].m_dblMiddle;
-	pInfo->m_dblINT   = CVector (pInfo->m_Paroi [0].m_slope [0].m_ptMiddle, pInfo->m_Paroi [0].m_slope [2].m_ptMiddle).Norm ()
-                       - pInfo->m_Paroi [0].m_slope [0].m_dblMiddle
-                       + pInfo->m_Paroi [0].m_slope [2].m_dblMiddle;
-
-	// dans le cas de la paroi, on additionne les deux �carts, car la paroi du bas est mesur�
-	// dans le sens oppos� � la paroi du haut
-	if (m_fDiameter)
-	{
-		pInfo->m_dblDia = CVector (pInfo->m_Paroi [0].m_slope [1].m_ptMiddle, pInfo->m_Paroi [1].m_slope [1].m_ptMiddle).Norm ()
-						+ pInfo->m_Paroi [0].m_slope [1].m_dblMiddle
-						+ pInfo->m_Paroi [1].m_slope [1].m_dblMiddle;
-	}
-	else // Calcul des moyennes des intensites entre les differents points
-	{
-		pInfo->m_dblEIMd = pInfo->m_dblINTd = pInfo->m_dblMEDd = 0.0;
-		long dw, nb=0, nbTot=0;
-
-		for ( dw=pInfo->m_Paroi[0].m_slope[0].m_dwMiddle; dw<pInfo->m_Paroi[0].m_slope[2].m_dwMiddle; dw++ )
-		{
-			nb++;
-			nbTot++;
-			pInfo->m_dblEIMd += m_bBuffer[dw];
-			pInfo->m_dblINTd += m_bBuffer[dw];
-		}
-
-		if (nb != 0 ) // Contre la division par 0 
-		{
-			pInfo->m_dblINTd /= (double) nb;  
-		}
-		else
-		{
-			pInfo->m_dblINTd = 0; 
-		}
-
-		nb = 0;
-		for ( dw=pInfo->m_Paroi[0].m_slope[2].m_dwMiddle; dw<pInfo->m_Paroi[0].m_slope[1].m_dwMiddle; dw++ )
-		{
-			nb++;
-			nbTot++;
-			pInfo->m_dblEIMd += m_bBuffer[dw];
-			pInfo->m_dblMEDd += m_bBuffer[dw];
-		}
-
-		if (nb != 0) // Contre la division par 0 
-		{
-			pInfo->m_dblMEDd /= (double) nb;  
-		}
-		else
-		{
-			pInfo->m_dblMEDd = 0; 
-		}
-
-		if (nbTot != 0) // Contre la division par 0 
-		{
-			pInfo->m_dblEIMd /= (double) nbTot; 
-		}
-		else
-		{
-			pInfo->m_dblEIMd = 0; 
-		}
-   }
-} // fin de ComputeEIM
-
-   
-/*----------------------------------------------------------\
-|                     Direction                             |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne la direction de la droite approxim�e constitu�e |
-|     d'apr�s l'ensemble des points mesur�s!                |
-\----------------------------------------------------------*/
-double CEIMBase::Direction()
-{
-	double r = 0;
-	double x = 0, y = 0;
-	Point LastPoint( 0, 0 );
-	double Valide = 0;
-	double sx, sx2, sy, sy2;
-	int nbPoints; 
-	double xmin, xmax, ymin, ymax; 
-	double moyx, moyy, stdx, stdy; 
-
-	if (m_pMeasures)
-	{
-		sx = sx2 = sy = sy2 = 0.0; 
-		nbPoints = 0; 
-
-		// Calcul de la somme des x et des y et de la somme des x2 et des y2 
-		CEIMInfo *pInfo = &m_pMeasures[0];
-		for (long dw = 0; dw < m_dwPoints; dw++)
-		{
-			if (pInfo->m_fValid)
-			{
-				if (dw)
-				{
-					x = (pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x - LastPoint.x);
-					y = (pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y - LastPoint.y);
-					if (x)
-					{
-						sx  += x; 
-						sx2 += (x * x); 
-						sy  += y; 
-						sy2 += (y * y); 
-						nbPoints++;
-					}
-				}
-				LastPoint = pInfo->m_Paroi[0].m_slope[0].m_ptDraw;
-			}
-			pInfo++;
-		}
-
-		// Calcul des moyennes et des �carts types 
-		if (nbPoints != 0) 
-		{
-			moyx = sx / (double) nbPoints;
-			moyy = sy / (double) nbPoints;
-
-			stdx = sqrt( (sx2 / (double) nbPoints) - sx * sx);
-			stdy = sqrt( (sy2 / (double) nbPoints) - sy * sy);
-
-			xmin = moyx - 2 * stdx; 
-			xmax = moyx + 2 * stdx; 
-			
-			ymin = moyy - 2 * stdy; 
-			ymax = moyy + 2 * stdy; 
-		}
-
-		pInfo = &m_pMeasures[0];
-		for (long dw = 0; dw < m_dwPoints; dw++)
-		{
-			if (pInfo->m_fValid)
-			{
-				if (dw)
-				{
-					x = (pInfo->m_Paroi[0].m_slope[0].m_ptDraw.x - LastPoint.x);
-					y = (pInfo->m_Paroi[0].m_slope[0].m_ptDraw.y - LastPoint.y);
-					if (x)
-					{
-//						if ((x >= xmin) && (x <= xmax) && (y >= ymin) && (y <= ymax))
-						{
-							r += y / x;
-							Valide++;
-						}
-					}
-				}
-
-				LastPoint = pInfo->m_Paroi[0].m_slope [0].m_ptDraw;
-			}
-			pInfo++;
-		}
-	}
-
-	if (Valide < 20) return 0; // Nombre de points valides insuffisants
-
-	Point PtDirect(100, (int) (100.0 * r / Valide));
-	PtDirect.Offset(m_vUser.StartPoint());
-
-	if ( (m_vUser.Angle(PtDirect) > 20) && (m_vUser.Angle(PtDirect) < 160) ) return 0;
-
-	return (r / Valide);
-}
-
-unsigned int CEIMBase::GetErrorID(void)
-{
-	return m_uErrorID;
-}

api.ipsocloud.com/math.backup/imt/EIMBase.h

@@ -1,161 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////
-/// Fichier EIMBase.h
-///
-////////////////////////////////////////////////////////////////////////////////////
-#pragma once
-
-/*----------------------------------------------------------\
-                        Includes
-\----------------------------------------------------------*/
-#include "scale.h"
-#include "vector.h"
-#include "CEIMInfo.h"
-
-#include <vector>
-#include <cassert>
-
-/*----------------------------------------------------------\
-                        Constantes
-\----------------------------------------------------------*/
-#define THICKNESS 300 // epaisseur sur laquelle le calcul est effectue
-//#define QI_MIN    60
-#define QI_MIN    5	// Provisoire : pour tests EIM Live 
-    
-#define MAX_POINTS_EIM_AUTO	1024
-
-/*----------------------------------------------------------\
-                       Classes
-\----------------------------------------------------------*/
-class CEIMResult;
-class QImage;
-    
-class CEIMBase
-{
-private:
-  	enum enumDirection
-   	{
-   		enumUp,
-   		enumDown
-   	};
-
-   	bool   LookForFirstPoint (long &, long, long &, unsigned char*);
-   	bool   LookForVariation  (long &, char   *, long, enumDirection, long &);
-   	bool   AddVector         (sParoi &);
-   	bool   FindOpposite      (sParoi &, sParoi &);
-   	void   SetMiddlePoint    (sSlope &, CVector &, bool reverseSlope=false);
-   	int    MeasureLineBuffer (sParoi &, unsigned char*, char *, long);
-   	void   ComputeEIM        (CEIMInfo *);
-	void   Paroi             (void);
-   	void   Diameter();
-	void   ParallelismeEIM();
-	void   ParallelismeDistensibilite();
-  	// élements liés à la mesure
-public:
-  	CEIMInfo  *m_pMeasures;         // pointeur sur mesures d'EIM.
-  	double	m_coeff_a, m_coeff_b, m_coeff_c; // Coefficient pour la courbe approximée 
-    bool	m_bNearWall;				// Indique si la mesure est pour le Near Wall ou le FarWall
-
-protected:
-   	CVector	m_vUser;             // vecteur parallèle à la paroi (normalement ...)
-    QImage  *m_image;
-  	double	m_minx_curve; 
-  	double	m_max_curve; 
-  	int		m_nbpoints_curve; 
-  	int		m_Max_Alignement;		// Indique la longueur utilisé pour l'alignement
-	int		m_indexParoi;
-	int		m_diag; // Pour le diagnostic de l'arret de l'algorithme 
-
-public: 
-	Point	m_ptDebut;
-  	Point	m_ptFin;
-protected:	
- 	Point m_pt1perp[MAX_POINTS_EIM_AUTO], m_pt2perp[MAX_POINTS_EIM_AUTO]; 
-  	Point m_perpap1, m_perpap2;
-
-   	std::vector<double> m_arVariance,
-   							m_arVarianceINT,
-   							m_arVarianceAA,
-   							m_arVarianceII;
-    
-   	unsigned int 	m_uErrorID;            // ID de la chaîne à afficher en cas d'erreur
-public: 
-   	unsigned char	m_bDelta1,
-            m_bDelta2;
-	unsigned char	m_bSeuil1;
-protected:	
-   	unsigned char	m_bBuffer  [THICKNESS];// stockage d'une ligne/colonne
-   	char	m_cOffsets [THICKNESS];// stockage de la variation de densite d'une ligne/colonne
-   	bool	m_fDiameter;           // type de la derniere mesure : diametre ou EIM
-    
-   	static char Delta (unsigned char b1, unsigned char b2);
-	virtual bool GfxImageValid() { return m_image != NULL; }
-public:
-   	bool	m_Assist;                // Horizontalisation automatique ou non!
- 
-	// Version de mesure de l'EIM qui améliore les résultats de l'EIM 
-	// Uniquement pour Tomtec pour la version 3.0  
-	bool m_versionTomtecAout08;
-
-	CEIMBase(void);
-   	virtual ~CEIMBase(void);
-    
-    virtual void  Release(void);
-    
-	inline bool Valid(void) const { return (m_dwValidPoints ? true : false); };
-    bool Measure(QImage *, const Point &, const Point &, bool, CEIMResult *m_res = NULL);
-
-	double Direction();
-    bool Update(CEIMResult *m_res = NULL);
-    virtual unsigned char IQ(void)
-    {
-		assert (m_pMeasures && m_image);
-    	return (unsigned char )(100 * m_dblQI);
-    }
-
-	virtual void GraphMeanInit() { }
-    virtual void GraphMeanAddMeasure( bool, double ) { }
-	virtual void PrintDiameter() { }
-	virtual void PrintErrorQIMin() { }
-	virtual void PrintResult() { }
-
-	virtual void SetEimAssisted(bool valide);	//  [JAK - 27/1/2003]Mesure de paroi assistée
-	bool	GetEimAssisted();				//  [JAK - 27/1/2003]
-    int		CalculEimAutomatique(int mode, bool bActionDiametre, Point *ptClick0, Point *ptClick1, Point *ptLastClick, unsigned char *bClicks, QImage* img,bool *fBackToNone);
-	int		CalculEimAutomatique(int mode, bool bActionDiametre, Point *ptClick0, Point *ptClick1, Point *ptLastClick, unsigned char *bClicks, bool *fBackToNone);
-	bool	Measure(const Point &, const Point &, bool, CEIMResult *m_res = NULL);
- 	Point	m_StartPoint;
-	Point	m_EndPoint;
-	bool	m_bDisplay; 
-    
-	enum enumAlgo
-	{
-		algoProfile,
-		algoSymmetry
-	};
-
-	long    m_dwPoints,                                     // nombre total de points (d'éléments de m_pMeasures)
-    		 m_dwValidPoints;                                // nombre de points ayant présenté le bon profil
-	double   m_dblEIMMax, m_dblEIMMean, m_dblEIMMin,		 // EIM
-    //#ifdef VERSION_SHOW_VARIANCE //  [JAK - 17/6/2002] 
-    		m_dblVariance,									// [JAK - 13/5/2002]
-    //#endif
-  			m_dblINTMax,   m_dblINTMean,   m_dblINTMin,     // Intima Max , Moyenne , et Min.
-  			m_dblEIMdMean, m_dblINTdMean,  m_dblMEDdMean,   // Media  Max , 
-			m_dblDiaAAMax, m_dblDiaAAMean, m_dblDiaAAMin,   // diamètre Adventice/Adventice Max , Moyen et Minimum
-			m_dblDiaIIMax, m_dblDiaIIMean, m_dblDiaIIMin,   // diamètres Intima/Intima Max , Moyen et Minimum
-			m_dblDistance,
-			m_dblQI,m_dblQIMean,
-   			m_dblIA, m_dblIAd;
-
-	std::string  m_strInfo;                                      // chaîne de résultat
-	enumAlgo m_algoDiameter;                                 // méthode utilisé pour le diamètre
-	double m_dblVarianceAA, m_dblVarianceII; 
-	bool	m_parallelismeDiametre; 
-    
-    //returns the last error generated.  
-    //Use CString.LoadString() to get the corresponding text
-    unsigned int GetErrorID(void);
-    virtual bool PointInBuffer(const Point& pt);
-	virtual unsigned char GetIntensity(const Point& pt);
-};
-    

api.ipsocloud.com/math.backup/imt/EIMResult.h

@@ -1,34 +0,0 @@
-#pragma once
-
-namespace imt
-{
-
-
-typedef struct Point
-{
-  int x;
-  int y;
-} Point;
-
-
-typedef struct IMTResult
-{
-  double imt_max;
-  double imt_mean;
-  double imt_standardDeviation;
-  double intima_mean;
-  double media_mean;
-  double qualityIndex;
-  double distance;
-  int    numberOfPoints;
-  Point* vect_intima;
-  Point* vect_media;
-  Point* vect_adventitia;
-  Point  p0;
-  Point  p1;
-} IMTResult;
-
-
-}
-
-

api.ipsocloud.com/math.backup/imt/MeanEstimate.cpp

@@ -1,399 +0,0 @@
-#include "MeanEstimate.h"
-
-#include <cassert>
-#include <cmath>
-#include <limits>
-#include <algorithm>
-#include <vector>
-
-
-
-
-CMeanEstimate::CMeanEstimate()
-{
-}
-
-CMeanEstimate::~CMeanEstimate(void)
-{
-}
-
-void  CMeanEstimate::RemoveValues(std::vector< double > *A, double value)
-{
-  A->erase( remove_if( A->begin(), A->end(), bind2nd( std::equal_to< double >(), value ) ), A->end() );
-
-/*
-	double x;
-	int size = (int)A->size();
-	int count=0; //number removed;
-	for(int i=0; i<size; i++)
-	{
-		x =  A->GetAt(i);
-		if( x == value )
-		{
-			A->RemoveAt(i);
-			count++;
-			i--;
-			size--;
-		}
-	}
-*/
-}
-
-struct is_not_a_number : public std::unary_function< double, bool >
-{
-  bool operator() ( double x )
-  {
-    return !CMeanEstimate::IsANumber( x );
-  }
-};
-
-void  CMeanEstimate::RemoveNanValues(std::vector< double > *A) // Nan = Not A Number
-{
-  A->erase( remove_if( A->begin(), A->end(), is_not_a_number() ), A->end() );
-
-/*
-	double x;
-	int size = (int)A->GetSize();
-	int count=0; //number removed;
-
-	for(int i=0; i<size; i++)
-	{
-		x =  A->GetAt(i);
-		if( ! CMeanEstimate::IsANumber(x) )
-		{
-			A->RemoveAt(i);
-			count++;
-			i--;
-			size--;
-		}
-	}
-*/
-}
-
-
-template < class Op1, class Op2, class Op3 >
-class binary_compose : public std::unary_function< typename Op2::argument_type,
-                                                   typename Op1::result_type >
-{
-  public:
-  
-    binary_compose( const Op1& o1, const Op2& o2, const Op3& o3 ) : f1( o1 ),
-                                                                    f2( o2 ),
-								    f3( o3 )
-    {
-    }
-    
-    typename Op1::result_type operator() ( const typename Op2::argument_type& x ) const
-    {
-      return f1( f2( x ), f3( x ) );
-    }
-    
-  protected:
-  
-    Op1 f1;
-    Op2 f2;
-    Op3 f3;
-};
-
-
-template < class Op1, class Op2, class Op3 >
-inline binary_compose< Op1, Op2, Op3 > compose2( const Op1& f1, const Op2& f2, const Op3& f3 )
-{
-  return binary_compose< Op1, Op2, Op3 >( f1, f2, f3 );
-}
-
-
-void  CMeanEstimate::RemoveOutOfBoundsValues(std::vector< double > *A, double percent)
-{
-	double mean = GetMeanEstimate(A, percent);
-	double maxBound = mean * (1+percent);
-	double minBound = mean * (1-percent);
-	
-  A->erase( remove_if( A->begin(), A->end(), 
-                       compose2( std::logical_or< bool >(),
-		                 std::bind2nd( std::less< double >(), minBound ),
-		                 std::bind2nd( std::greater< double >(), maxBound ) ) ), 
-		       A->end() );
-	
-/*
-	double x=0;
-	
-	int size = (int)A->GetSize();
-	int count=0; //number removed;
-	
-	for(int i=0; i<size; i++)
-	{
-		x =  A->GetAt(i);
-		if( x > maxBound || x < minBound )
-		{
-			A->RemoveAt(i);
-			count++;
-			i--;
-			size--;
-		}
-	}
-*/
-}
-
-void  CMeanEstimate::FindMinMaxWithinBoundsValues(std::vector< double > *A, double percent, double &min, double &max)
-{
-	std::vector< double > A2(*A);
-	RemoveValues(&A2, -1);
-	RemoveValues(&A2, 0);
-	RemoveNanValues(&A2);
-
-	min = std::numeric_limits<double>::max();
-	max = std::numeric_limits<double>::min();
-	double mean = GetMeanEstimate(&A2, percent);
-	double maxBound = mean * (1+percent);
-	double minBound = mean * (1-percent);
-	double x=0;
-	int i = 0;
-	double value=-1;
-	
-	std::vector< double >::iterator 
-	  it = A->begin(),
-	  ie = A->end();
-	
-	while (it != ie)
-	{
-		x =  *it;
-		if(    !CMeanEstimate::IsANumber(x)
-			|| x<=0){	
-
-		}else{	
-			if (x > maxBound || x < minBound )
-			{
-			}else{
-				if( x > max ){ 
-					max = x;
-				}else{			
-					if(x < min ){
-						min = x;
-					}
-				}
-			}
-		}
-	  i++;
-          ++it;
-	}	
-}
-
-void  CMeanEstimate::FindMinMax(std::vector< double > *A, double &min, double &max)
-{
-	min = std::numeric_limits<double>::max();
-	max = std::numeric_limits<double>::min();
-	//min = max = A->GetAt(0);
-	double x=0;
-	std::vector< double >::iterator
-	  it = A->begin(),
-	  ie = A->end();
-	
-	while ( it != ie )
-	{
-		x = *it;
-		if( x > max ) max = x;
-		if(x>0 && x < min ) min = x;
-		++it;
-	}
-}
-
-double CMeanEstimate::GetMeanEstimate(std::vector< double > *A)
-{	
-	return GetMeanEstimate(A, VARIATION_COEF);
-}
-
-double CMeanEstimate::GetMeanEstimate(std::vector< double > *A, double similarityCoef)
-{
-	double mean=GetMean(A);
-	double x=0, sum = 0 ;
-	int count=0;
-	//double maxDeviation = mean * similarityCoef;
-	std::vector< double >::iterator
-	  it = A->begin(),
-	  ie = A->end();
-	
-	while ( it != ie )
-	{
-		x = *it;
-		//if(maxDeviation> fabs(x-mean)){
-		if( x*similarityCoef > fabs(x-mean) )
-		{
-			sum+=x;
-			count++;
-		}
-		else
-		{
-			int xxx=0; xxx++;
-		}
-		
-		++it;
-	}
-//	VERIFY(count);
-	return sum / (double)count;
-}
-
-double CMeanEstimate::GetMeanEstimateFileOutput(std::vector< double > *A, double similarityCoef)
-{
-	double mean=GetMean(A);
-	double x=0, sum = 0 ;
-	int count=0;
-	//double maxDeviation = mean * similarityCoef;
-	std::vector< double >::iterator
-	  it = A->begin(),
-	  ie = A->end();
-	
-	while ( it != ie )
-	{
-		x =  *it;
-		//if(maxDeviation> fabs(x-mean)){
-		if( x*similarityCoef > fabs(x-mean) )
-		{
-			sum+=x;
-			count++;
-		}
-		
-		++it;
-	}
-//#define OUTPUT 
-#ifdef OUTPUT
-	fprintf(m_file, "%d",count);
-#endif
-	//VERIFY(count);
-	return sum / (double)count;
-}
-
-void CMeanEstimate::PrintMeanEstimate(std::vector< double > *A, std::vector< double > *B)
-{
-	PrintMeanEstimate(A,B, VARIATION_COEF);
-}
-
-void CMeanEstimate::PrintMeanEstimate(std::vector< double > *A, std::vector< double > *B, double similarityCoef)
-{
-	double mean =GetMean(A);
-	double meanB=GetMean(B);
-	double x=0;
-	int count=0, countB=0;
-	//fprintf(m_file, "MeanEstimate, coef:%f\n %f \t%f\n\n",similarityCoef, GetMeanEstimate(A,similarityCoef), GetMeanEstimate(B,similarityCoef));
-	//fprintf(m_file, "AA\t exclu=0\t\tII\t exclu=0\n");
-	//double maxDeviation = mean * similarityCoef;
-	//double maxDeviationB = meanB * similarityCoef;
-	
-	assert( B->size() <= A->size() );
-	std::vector< double >::iterator
-	  ia = A->begin(),
-	  ae = A->end(),
-	  ib = B->begin();
-
-	while ( ia != ae )
-	{
-		x =  *ia;
-		//if(maxDeviation > fabs(x-mean) ){
-		if ( x*similarityCoef > fabs(x-mean) )
-		{
-			//sum+=x;
-			//fprintf(m_file, "%f\t1\t", x);
-		}
-		else
-		{
-			count++;
-			//fprintf(m_file, "%f\t0\t", x);
-		}
-		x =  *ib;
-		//fprintf(m_file, "\t");
-		//if(maxDeviationB> fabs(x-meanB) ){
-		if( x*similarityCoef > fabs(x-meanB) )
-		{
-			//sumB+=x;
-			//fprintf(m_file, "%f\t1\t", x);
-		}
-		else
-		{
-			countB++;
-			//fprintf(m_file, "%f\t0\t", x);
-		}
-		//fprintf(m_file, "\n");
-		
-		++ia;
-		++ib;
-	}
-		//fprintf(m_file, "\nnombre de points exclus:\t%d\t\t\t%d\n",count, countB );
-}
-
-bool CMeanEstimate::IsANumber(double x)
-{
-	return ((x < (double)(std::numeric_limits<double>::max())) && 
-		(x > (double)(std::numeric_limits<double>::min())));
-}
-
-double CMeanEstimate::GetMean(std::vector< double > *A)
-{
-	double sum=0;
-	double x=0;
-	std::vector< double >::iterator
-	  it = A->begin(),
-	  ie = A->end();
-
-	while ( it != ie )
-	{
-		x = *it;
-		if( !IsANumber(x)  )
-		{
-			int xxx=0; xxx++;
-		} else
-//		if( x == std::numeric_limits<double>::quiet_NaN() ){
-//			int xxx=0; xxx++;
-//		}
-//		if( abs(x) == std::numeric_limits<double>::infinity() ){
-//			int xxx=0; xxx++;
-//		}
-		sum+= x;
-		
-		++it;
-	}
-	return sum / (double)A->size();
-}
-
-double CMeanEstimate::GetStandardDeviation(std::vector< double > *A)
-{
-	return sqrt(GetVariance(A));
-}
-
-double CMeanEstimate::GetVariance(std::vector< double > *A)
-{
-	double mean=GetMean(A);
-	double sum=0, diff=0;
-	std::vector< double >::iterator
-	  it = A->begin(),
-	  ie = A->end();
-	
-	while ( it != ie )
-	{
-		diff = *it - mean;
-		sum+= diff*diff;
-		++it;
-	}
-	return sum / (double)A->size();
-}
-
-//void CMeanEstimate::OutputToFile(char* filename, CArray<double> *A, CArray<double> *B)
-////implementation rapide et specifique est repectant peu le principde objet !!
-//{
-//	FILE* file = fopen(filename, "a");
-//
-//	if(file==0){
-//		ASSERT(file);
-//	}else{		
-//		fprintf(file, "Mean\n %f \t %f \n", CMeanEstimate::GetMean(A), CMeanEstimate::GetMean(B));
-//		fprintf(file, "StandardDeviation\n %f \t %f \n", CMeanEstimate::GetStandardDeviation(A), CMeanEstimate::GetStandardDeviation(B));
-//		fprintf(file, "\nValues:\nAA \tII\n");
-//		ASSERT(A->GetSize()==B->GetSize());
-//		for(int i=A->GetSize()-1; i; i--){
-//			fprintf(file, "%g \t %g \n", A->GetAt(i), B->GetAt(i));
-//		}
-//		fprintf(file, "\n\n");
-//		fclose(file);
-//	}
-//}
-
-

api.ipsocloud.com/math.backup/imt/MeanEstimate.h

@@ -1,42 +0,0 @@
-#pragma once
-
-
-#include <cstdio>
-#include <map>
-#include <vector>
-#include <functional>
-
-
-#define VARIATION_COEF 0.02
-
-
-
-class CMeanEstimate
-{
-  public:
-  
-    static bool IsANumber(double x);
-
-    static void RemoveNanValues(std::vector<double> *A);
-    static void RemoveValues(std::vector<double> *A, double value);
-    static void RemoveOutOfBoundsValues(std::vector<double> *A, double percent);//precent : Bounds are the means +/- percent of the mean 
-    static void FindMinMax(std::vector<double> *A, double &min, double &max);
-    static void FindMinMaxWithinBoundsValues(std::vector<double> *A, double percent, double &min, double &max);
-
-    static double GetVariance(std::vector<double> *A);
-    static double GetStandardDeviation(std::vector<double> *A);
-    static double GetMean(std::vector<double> *A);
-
-    static double GetMeanEstimate(std::vector<double> *A, double similarityCoef);
-    static double GetMeanEstimate(std::vector<double> *A);
-    static double GetMeanEstimateFileOutput(std::vector<double> *A, double similarityCoef=VARIATION_COEF);
-
-    static void PrintMeanEstimate(std::vector<double> *A, std::vector<double> *B);
-    static void PrintMeanEstimate(std::vector<double> *A, std::vector<double> *B, double similarityCoef);
-
-  protected:
-
-    CMeanEstimate();
-    virtual ~CMeanEstimate();
-};
-

api.ipsocloud.com/math.backup/imt/Ressource.h

@@ -1,11 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////
-/// Fichier Ressource.h
-///
-////////////////////////////////////////////////////////////////////////////////////
-#pragma once
-
-//#define MATH_DLL
-#define IDS_EIM_INVALID     45088
-#define IDS_EIM_FAILED      45090
-#define IDS_EIM_DIA_RESULT9 45093
-

api.ipsocloud.com/math.backup/imt/ToolsMath.cpp

@@ -1,353 +0,0 @@
-#include "ToolsMath.h"
-
-#include <cmath>
-#include <limits>
-
-//------------------------------------------------------//
-//       Fonctions Mathématiques diverses (by CJ)       //
-//------------------------------------------------------//
-
-// Calcul la distance entre 2 points 
-double distance(dpoint pt1, dpoint pt2) 
-{
-  double dist; 
-
-  dist = std::sqrt((pt1.x - pt2.x) * (pt1.x - pt2.x) + (pt1.y - pt2.y) * (pt1.y - pt2.y));
-
-  if (dist < 0.000001) 
-  {
-    dist = 0; 
-  }
-
-  return dist;
-}
-
-// Renvoie les coefficients p1 et d1 de la droite y = p1.x + b1,  à partir de 2 points
-void GetCoeffDroite(dpoint pt1, dpoint pt2, double *p1, double *d1, double *b1) 
-{		
-  // Leger bug pour des écarts très petits 
-  if (fabs(pt1.x - pt2.x) < 0.001) 
-  {
-    pt1.x = pt2.x; 
-  }
-	
-  if (fabs(pt1.y - pt2.y) < 0.001) 
-  {
-    pt1.y = pt2.y; 
-  }
-							
-  // Calcul des coefficients de la droite
-  *p1 = (double)std::numeric_limits< int >::max();  
-  *d1 = pt2.x - pt1.x;
-  if (*d1 != 0) 
-  {
-    *p1 = (pt2.y - pt1.y) / (*d1);
-    *b1 = pt1.y - ((*p1) * pt1.x);
-  }	
-}
-
-// Renvoie le point (sol1 ou sol2) le plus proche de p1
-dpoint leplusproche(dpoint vPoint, dpoint sol1, dpoint sol2) 
-{
-  double dist1, dist2; 
-  dpoint res; 
-
-  dist1 = distance(vPoint, sol1);
-  dist2 = distance(vPoint, sol2);
-	
-  if (dist1 < dist2) 
-  {
-    res.x = sol1.x; 
-    res.y = sol1.y;
-  } 
-  else 
-  {
-    res.x = sol2.x;
-    res.y = sol2.y;
-  }
-
-  return res; 
-}
-
-// Calcul des 2 points d'intersection entre un cercle et une droite définie par 2 points 
-bool InterCercleDroite(dpoint p0, double r, dpoint d1, dpoint d2, dpoint *sr1, dpoint *sr2) 
-{
-  double a, b, d; 
-  double ka, kb, kc, delta; 
-  dpoint s1, s2; 
-  bool trouve; 
-
-  trouve = false; 
-
-  s1.x = -1; 
-  s1.y = -1; 
-  s2.x = -1; 
-  s2.y = -1; 
-
-  // Coefficient de la droite définie par 2 pts successifs
-  // Droite y = a.x + b 
-  GetCoeffDroite(d1, d2, &a, &d, &b);
-
-  if ((d != 0) && (a != 0)) 
-  { // Cas normal 
-    ka = 1 + (a * a); 
-    kb = (2 * a * b) - (2 * p0.x) - (2 * a * p0.y);
-    kc = (b * b) - (2 * b * p0.y) - ((r * r) - (p0.x * p0.x) - (p0.y * p0.y));
-
-    delta = (kb * kb) - (4 * ka * kc);
-
-    if (delta == 0) 
-    {
-      s1.x = -kb / (2 * ka);
-      s2.x = s1.x;
-    } 
-    else if (delta > 0) 
-    {
-      s1.x = (-kb - sqrt(delta)) / (2 * ka);
-      s2.x = (-kb + sqrt(delta)) / (2 * ka);
-    }
-
-    if (delta >= 0) 
-    {
-      s1.y = a * s1.x + b;
-      s2.y = a * s2.x + b;
-      trouve = true; 
-    }
-  } 
-  else if (d == 0) 
-  { // La droite est verticale 
-    ka = 1; 
-    kb = -2 * p0.y;
-    kc = (d1.x * d1.x) - (2 * d1.x * p0.x) - ((r * r) - (p0.x * p0.x) - (p0.y * p0.y));
-
-    delta = (kb * kb) - (4 * ka * kc);
-
-    if (delta == 0) 
-    {
-      s1.y = -kb / (2 * ka);
-      s2.y = s1.y;
-    } 
-    else if (delta > 0) 
-    {
-      s1.y = (-kb - sqrt(delta)) / (2 * ka);
-      s2.y = (-kb + sqrt(delta)) / (2 * ka);
-    }
-
-    if (delta >= 0) 
-    {
-      s1.x = d1.x; 
-      s2.x = d1.x; 
-      trouve = true;
-    }
-  } 
-  else if (a == 0) 
-  { // La droite est horizontale 
-    ka = 1; 
-    kb = -2 * p0.x;
-    kc = (d1.y * d1.y) - (2 * d1.y * p0.y) - ((r * r) - (p0.x * p0.x) - (p0.y * p0.y));
-
-    delta = (kb * kb) - (4 * ka * kc);
-
-    if (delta == 0) 
-    {
-      s1.x = -kb / (2 * ka);
-      s2.x = s1.x;
-    } 
-    else if (delta > 0) 
-    {
-      s1.x = (-kb - sqrt(delta)) / (2 * ka);
-      s2.x = (-kb + sqrt(delta)) / (2 * ka);
-    }
-
-    if (delta >= 0) 
-    {
-      s1.y = d1.y; 
-      s2.y = d1.y; 
-      trouve = true; 
-    }	
-  }
-
-  sr1->x = s1.x; 
-  sr1->y = s1.y;
-  sr2->x = s2.x;
-  sr2->y = s2.y;
-
-  return trouve; 
-}
-
-// Parabole y = a*x^2 + b*x + c  (by FP)
-//
-// N : nombre de points (i.e. taille des vecteurs x[] et y[])
-// x : vecteurs des abscisses
-// y : vecteurs des ordonees
-// a, b, c : les 3 coefficients recherches
-void moindres_carres_parabole(int N, dpoint *points, double *a, double *b, double *c)
-{
-  int i;
-  double d, d1, d2, d3; 
-  double sx = 0.0;
-  double sx2 = 0.0;
-  double sx3 = 0.0;
-  double sx4 = 0.0;
-  double sy = 0.0;
-  double syx = 0.0;
-  double syx2 = 0.0;
-  double x2;
-
-  for ( i = 0; i < N; i++ )
-  {
-     
-    sx   += points[i].x;
-    sx2  += ( x2 = points[i].x * points[i].x );
-    sx3  += x2 * points[i].x;
-    sx4  += x2 * x2;
-    sy   += points[i].y;
-    syx  += points[i].y * points[i].x;
-    syx2 += points[i].y * x2;
-  }
-
-  d  = sx4 * ( (double) N * sx2 - sx * sx ) + sx3 * ( sx * sx2 - (double) N * sx3 ) + sx2 * ( sx * sx3 - sx2 * sx2 );
-  d1 = sx4 * ( sx2 * sy - sx * syx ) + sx3 * ( sx * syx2 - sx3 * sy) + sx2 * ( sx3 * syx - sx2 * syx2 );
-  d2 = sx4 * ( (double) N * syx - sy * sx ) + sx3 * ( sy * sx2 - (double) N * syx2 ) + sx2 * ( syx2 * sx - syx * sx2 );
-  d3 = syx2 * ( (double) N * sx2 - sx * sx ) + syx * ( sx * sx2 - (double) N * sx3 ) + sy * ( sx * sx3 - sx2 * sx2 );
-
-  if (d != 0) 
-  {
-    *c = d1 / d;	
-    *b = d2 / d;
-    *a = d3 / d;
-  }
-  else
-  {
-    *a = *b = *c = 0;
-  }
-}
-
-// Regression linéaire 
-// Trouve les coefficients de la droite y = bx + a, à partir des points, par regression linéaire
-void RegressionLineaire(int n, dpoint *points, double *b, double *a) 
-{
-  // calculate the averages of arrays x and y
-  double xa = 0, ya = 0;
-
-  for (int i = 0; i < n; i++) 
-  {
-    xa += points[i].x;
-    ya += points[i].y;
-  }
-
-  if (n != 0)
-  {
-    xa /= n;
-    ya /= n;
-  }
-  else
-  {
-    xa = 0; 
-    ya = 0; 
-  }
-
-  // calculate auxiliary sums
-  double xx = 0, yy = 0, xy = 0;
-
-  for (int i = 0; i < n; i++) 
-  {
-    double tmpx = points[i].x - xa, tmpy = points[i].y - ya;
-    xx += tmpx * tmpx;
-    yy += tmpy * tmpy;
-    xy += tmpx * tmpy;
-  }
- 
-  // calculate regression line parameters
- 
-  // make sure slope is not infinite
-  // assert(fabs(xx) != 0);
- 
-  if (xx != 0)
-  {
-    *b = xy / xx;
-  }
-  else
-  {
-    *b = 0; 
-  }
-
-  *a = ya - *b * xa;
-
-  //  Coefficient de regression 
-  //  double coeff; 
-  //  coeff = (fabs(yy) == 0) ? 1 : xy / sqrt(xx * yy);
-}
-
-
-// Calcul la distance orthogonale entre le point vpt 
-// et la droite définie par les 2 points pt1 et pt2
-double distanceOrthPtDroite(dpoint vpt, dpoint pt1, dpoint pt2, dpoint *pres)
-{
-  double p1, d1, b1, b2, dist; 
-
-  GetCoeffDroite(pt1, pt2, &p1, &d1, &b1);
-
-  if ((p1 != 0) && (d1 != 0))
-  {
-    // Perpendiculaire qui passe par vpt 
-    b2 = vpt.y + ((1/p1) * vpt.x);
-
-    // Point de rencontre (qui passe par pb)
-    pres->x = (double) (b2 - b1) / (double) (p1 + (1/p1));
-    pres->y = (double) p1 * (pres->x) + b1;
-  } 
-  else if (p1 == 0) 
-  { // pt1-pt2 horizontale
-    pres->x = vpt.x;
-    pres->y = pt1.y;
-  }
-  else if (d1 == 0)
-  { // verticale 
-    pres->x = pt1.x;
-    pres->y = vpt.y;
-  }
-
-  dist = distance(*pres, vpt); 
-  return dist; 
-}
-
-
-// Point in Polygon d'après FAQ comp.graphics
-bool PtInPolygon(double vx, double vy, dpoint *tpoint, int nbpoint) 
-{
-  int i, j; 
-  bool c; 
-
-  c = false;  
-
-  for (i = 0, j = nbpoint-1; i < nbpoint; j = i++) 
-  {
-    if ((((tpoint[i].y <= vy) && (vy < tpoint[j].y)) ||
-         ((tpoint[j].y <= vy) && (vy < tpoint[i].y))) && 
-         (vx < (tpoint[j].x - tpoint[i].x) * (vy - tpoint[i].y) / (tpoint[j].y - tpoint[i].y) + tpoint[i].x))
-    {
-      c = !c;
-    }
-  }
-
-  return c; 
-}
-
-// Est ce que le point x, y est dans l'ellipse a, b 
-bool PtInEllipse(double x, double y, double a, double b)
-{
-  double result = 10.0; 
-
-  if ((a != 0.0) && (b != 0.0)) 
-  {
-    result = ((x / a) * (x / a)) + ((y / b) * (y / b));
-  }
-
-  if (result <= 1) 
-  {
-    return true; 
-  }
-
-  return false; 
-}

api.ipsocloud.com/math.backup/imt/ToolsMath.h

@@ -1,21 +0,0 @@
-#pragma once
-
-// Structure d'un point reel
-
-struct dpoint 
-{
-  double x;
-  double y;
-};
-
-
-double distance(dpoint pt1, dpoint pt2); 
-void GetCoeffDroite(dpoint pt1, dpoint pt2, double *p1, double *d1, double *b1); 
-bool InterCercleDroite(dpoint p0, double r, dpoint d1, dpoint d2, dpoint *sr1, dpoint *sr2);
-dpoint leplusproche(dpoint vPoint, dpoint sol1, dpoint sol2);
-void moindres_carres_parabole(int N, dpoint *points, double *a, double *b, double *c);
-void RegressionLineaire(int n, dpoint *points, double *a, double *b);
-double distanceOrthPtDroite(dpoint vpt, dpoint pt1, dpoint pt2, dpoint *pres);
-bool PtInPolygon(double vx, double vy, dpoint *tpoint, int nbpoint); 
-bool PtInEllipse(double x, double y, double a, double b);
-

api.ipsocloud.com/math.backup/imt/point.cpp

@@ -1,78 +0,0 @@
-#include "point.h"
-
-
-Point::Point( int px, int py )
-     : x( px ),
-       y( py )
-{
-}
-
-
-Point::Point( const Point& other )
-     : x( other.x ),
-       y( other.y )
-{
-}
-
-
-void Point::Offset( int xOffset, int yOffset )
-{
-
-  x += xOffset;
-  y += yOffset;
-
-}
-
-
-void Point::Offset( const Point& point )
-{
-
-  x += point.x;
-  y += point.y;
-
-}
-
-
-Point& Point::operator += ( const Point& other )
-{
-
-  x += other.x;
-  y += other.y;
-  
-  return *this;
-
-}
-
-
-Point& Point::operator -= ( const Point& other )
-{
-
-  x -= other.x;
-  y -= other.y;
-  
-  return *this;
-
-}
-
-
-Point operator + ( const Point& p1, const Point& p2 )
-{
-
-  return Point( p1.x + p2.x, p1.y + p2.y );
-
-}
-
-
-Point operator - ( const Point& p1, const Point& p2 )
-{
-
-  return Point( p1.x - p2.x, p1.y - p2.y );
-
-}
-
-bool operator == ( const Point& p1, const Point& p2 )
-{
-
-  return ( ( p1.x == p2.x ) && ( p1.y == p2.y ) );
-
-}

api.ipsocloud.com/math.backup/imt/point.h

@@ -1,28 +0,0 @@
-#pragma once
-
-
-struct Point
-{
-
-  public:
-  
-    Point( int px = 0, int py = 0 );
-    Point( const Point& other );
-    
-    void Offset( int xOffset, int yOffset );
-    void Offset( const Point& point );
-    
-    Point& operator += ( const Point& other );
-    Point& operator -= ( const Point& other );
-
-    int x;
-    int y;
-
-};
-
-
-Point operator + ( const Point& p1, const Point& p2 );
-Point operator - ( const Point& p1, const Point& p2 );
-bool operator == ( const Point& p1, const Point& p2 );
-
-

api.ipsocloud.com/math.backup/imt/rectangle.cpp

@@ -1,133 +0,0 @@
-#include "rectangle.h"
-
-
-Rect::Rect( int x1, int y1, int x2, int y2 )
-{
-
-  if ( x1 < x2 )
-  {
-  
-    left = x1;
-    right = x2;
-  
-  }
-  else
-  {
-  
-    left = x2;
-    right = x1;
-  
-  }
-
-  if ( y1 < y2 )
-  {
-  
-    top = y1;
-    bottom = y2;
-  
-  }
-  else
-  {
-  
-    top = y2;
-    bottom = y1;
-  
-  }
-
-}
-
-
-Rect::Rect( const Point& p1, const Point& p2 )
-{
-
-  if ( p1.x < p2.x )
-  {
-  
-    left = p1.x;
-    right = p2.x;
-  
-  }
-  else
-  {
-  
-    left = p2.x;
-    right = p1.x;
-  
-  }
-
-  if ( p1.y < p2.y )
-  {
-  
-    top = p1.y;
-    bottom = p2.y;
-  
-  }
-  else
-  {
-  
-    top = p2.y;
-    bottom = p1.y;
-  
-  }
-
-}
-
-
-Rect::Rect( const Rect& other )
-     : left( other.left ),
-       top( other.top ),
-       right( other.right ),
-       bottom( other.bottom )
-{
-}
-
-
-Rect::~Rect()
-{
-}
-
-
-Point Rect::TopLeft()
-{
-
-  Point p( left, top );
-  
-  return p;
-
-}
-
-
-Point Rect::BottomRight()
-{
-
-  Point p( right, bottom );
-  
-  return p;
-
-}
-
-
-Point Rect::CenterPoint()
-{
-
-  Point p( ( right - left ) / 2, ( bottom - top ) / 2 );
-
-  return p;
-
-}
-
-
-int Rect::Width()
-{
-
-  return right - left + 1;
-
-}
-
-
-int Rect::Height()
-{
-
-  return bottom - top + 1;
-
-}

api.ipsocloud.com/math.backup/imt/rectangle.h

@@ -1,31 +0,0 @@
-#pragma once
-
-
-#include "point.h"
- 
-
-class Rect
-{
-
-  public:
-  
-    Rect( int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0 );
-    Rect( const Point& p1, const Point& p2 );
-    Rect( const Rect& other );
-    virtual ~Rect();
-
-    Point TopLeft();
-    Point BottomRight();
-    Point CenterPoint();
-    
-    int Width();
-    int Height();
-  
-    int left;
-    int top;
-    int right;
-    int bottom;
-  
-};
-
-

api.ipsocloud.com/math.backup/imt/scale.cpp

@@ -1,187 +0,0 @@
-/*******************************************************************\
-
-    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

api.ipsocloud.com/math.backup/imt/scale.h

@@ -1,77 +0,0 @@
-#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;
-

api.ipsocloud.com/math.backup/imt/vector.cpp

@@ -1,557 +0,0 @@
-/*******************************************************************
-    Fichier     : Vector.cpp
-    Date        : 28/04/98
-    Version     : 1.001
-    Description : Classe de gestion des vecteurs
-|*******************************************************************|
-
-Bugs:
-   Le troisieme point n'est pas pris en compte pour le calcul du 
-      vecteur orthogonal
-   La fonction angle n'est pas validee
-   Le calcul du vecteur orthogonal serait surement + rapide en calculant
-      le produit scalaire du vecteur avec le vecteur forme par le point
-      et son projete orthogonal sur le vecteur
-Notes:
-   on pourrait utiliser controlfp plutot qu'ajouter .5 lors des conversions
-      flottant vers entier
-   La longueur (nombre de points requis pour trace le vecteur) du
-      vecteur est une valeur signee, afin de permettre la recuperation
-      des points n'appartenant pas au vecteur, mais a la droite dont
-      le vecteur est support.
-      operator [-1], retourne par exemple le point juste avant m_pt1
-|*******************************************************************|
-Historique :
-   28/04/98 1.001 : Fonction de translation d'un vecteur
-   20/06/97 1.000 : Première version
-|*******************************************************************/
-
-#include "scale.h"
-
-    
-/*----------------------------------------------------------\
-                        Fonctions locales
-\----------------------------------------------------------*/
-inline long Double2Long(double d)
-{
-  if (d < 0) 
-  {
-    d -= .5;
-  }
-  else
-  {
-    d += .5;
-  }
-  
-  return (long (d));
-}
-    
-/*----------------------------------------------------------\
-|                     CVector                               |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Constructeurs de l'objet                                 |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|           Si aucun, un vecteur nul est créé               |
-|  pt1, pt2 : deux points définissants le support du vecteur|
-\----------------------------------------------------------*/
-CVector::CVector (void)
-       : m_pt1 (0,0), // petite optimisation, sinon le constructeur vide
-         m_pt2 (0,0)  // est appelé avant que l'on affecte réellement les points
-{
-  Update ();
-} // end of CVector
-    
-CVector::CVector(const Point &pt1, const Point &pt2)
-       : m_pt1 (pt1),
-	 m_pt2 (pt2)
-{
-  Update ();
-} // end of CVector
-    
-CVector::CVector(int x1, int y1, int x2, int y2)
-       : m_pt1 (x1, y1),
-	 m_pt2 (x2, y2)
-{
-  Update ();
-} // end of CVector
-    
-/*----------------------------------------------------------\
-|                         =                                 |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Opérateur de copie                                       |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|           Si aucun, un vecteur nul est créé               |
-|  pt1, pt2 : deux points définissants le support du vecteur|
-\----------------------------------------------------------*/
-const CVector &CVector::operator = (const CVector &vSource)
-{
-  m_pt1 = vSource.m_pt1;
-  m_pt2 = vSource.m_pt2;
-  Update();
-  
-  return (*this);
-} // fin de =
-    
-/*----------------------------------------------------------\
-|                     Update                                |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Calcule les valeurs de tous les membres à partir des     |
-|     points extrêmes du vecteur                            |
-|  A appeler à chaque modification de l'un de ces points.   |
-\----------------------------------------------------------*/
-void CVector::Update(void)
-{
-	// calcul des variations
-    m_lDeltaX = m_pt2.x - m_pt1.x;
-    m_lDeltaY = m_pt2.y - m_pt1.y;
-    
-    // calcul de la norme
-    // cela ne devrait jamais arriver (sur un écran), mais en cas de bug...
-    //   la somme des produits peut être > à 2x10e9 et donner un résultat
-    //   négatif, ce qui n'arrange pas vraiment la fonction sqrt
-    // le DWORD final bien que théoriquement insuffisant, fonctionne car
-    //   on traite des vecteurs sur un écran, on évite simplement un plantage
-    //   en cas de bug
-    // MAIS on fausse alors le calcul. Une gestion d'exception adequat serait plus judicieuse !!
-    long test1 = ((m_lDeltaX * m_lDeltaX) + (m_lDeltaY * m_lDeltaY));
-  //DWORD test2 = DWORD ((m_lDeltaX * m_lDeltaX) + (m_lDeltaY * m_lDeltaY));
-  //double test3 = sqrt(test1);
-    double test3 = sqrt((double) test1); // MAJ2005
-  //double test4 = sqrt(test2);
-
-  //m_dblNorm = sqrt (DWORD ((m_lDeltaX * m_lDeltaX) + (m_lDeltaY * m_lDeltaY)));
-    m_dblNorm = sqrt ((double) long ((m_lDeltaX * m_lDeltaX) + (m_lDeltaY * m_lDeltaY)));
-    m_dblNorm = test3;
-    
-    // détermination de la variation la plus importante
-    m_fHorizontal = (abs (m_lDeltaX) > abs (m_lDeltaY));
-    
-    // calcul du nombre de points requis pour tracer une droite
-    if (m_fHorizontal)   m_dwSize = abs (m_lDeltaX);
-    else                 m_dwSize = abs (m_lDeltaY);
-} // fin de Update
-    
-/*----------------------------------------------------------\
-|                     operator []                           |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne les coordonnées d'un point du segement          |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  lIndex : position du point sur le segment                |
-|              signé afin de pouvoir obtenir les coordonées |
-|              des points de la droite aussi.               |
-|-----------------------------------------------------------|
-| RETOUR :                                                  |
-|  le point voulu                                           |
-\----------------------------------------------------------*/
-Point CVector::operator [] (long lIndex) const
-{
-   // pour le vecteur nul il aurait mieux valu ne pas appeler la fonction
-   if (Nul ())
-   {
-      return Point (0,0);
-   }
-   else if (lIndex)
-   {
-      // le double est essentiel, sinon tout est converti en NON signé!!!
-      return (Point (m_pt1.x + Double2Long (m_lDeltaX * lIndex / double (Length ())),
-                     m_pt1.y + Double2Long (m_lDeltaY * lIndex / double (Length ()))
-                     )
-             );
-   }
-   else
-      return (m_pt1);
-} // end of operator []
-    
-/*----------------------------------------------------------\
-|                     PosFromPoint                          |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne la position que doit avoir le point s'il fait   |
-|     partie de la droite                                   |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pt : le point en question                                |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  la position estimée                                      |
-\----------------------------------------------------------*/
-long CVector::PosFromPoint (const Point &pt) const
-{
-   // calcul de la position approximative
-   if (Nul ())
-   {
-      return (0);
-   }
-   else
-   {
-      // que de problèmes je me suis faits pour pas grand-chose !!
-      // en fonction du sens, on obtient directement la position
-      //    du point, puisqu'il y a UN point ajouté à chaque fois
-      //    sans recouvrement dans le sens de variation
-      //    LONG ((pt.x - m_pt1.x) * Length () / double (m_lDeltaX)) = (pt.x - m_pt1.x) * sign(m_lDeltaX)
-      //                             = m_lDeltaX !!
-      // ça sert parfois de prendre le temps de réfléchir !!
-      if (m_fHorizontal)
-         return (m_lDeltaX > 0 ? pt.x - m_pt1.x : m_pt1.x - pt.x);
-      else
-         return (m_lDeltaY > 0 ? pt.y - m_pt1.y : m_pt1.y - pt.y);
-   }
-} // fin de PosFromPoint
-    
-/*----------------------------------------------------------\
-|                     PointInVector                         |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Détermine si un point donné appartient au segment        |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pt : le point en question                                |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un booléen                                               |
-\----------------------------------------------------------*/
-bool CVector::PointInVector (const Point &pt) const
-{
-   // calcul de la position approximative
-   // la position en X, doit être la même que la position en Y, logique...
-   // donc un seul calcul suffit
-   if (Nul ())
-   {
-      return (false);
-   }
-   else
-   {
-      long lPos = PosFromPoint (pt);
-    
-      // on regarde aussi si l'un des deux extrêmes ne fait pas partie du segment
-      //    à cause des arrondis
-      // si la position est hors limite, on court-circuite le test, d'autant
-      if ((lPos < 0) || (long (lPos) > Length ()))
-         return (false);
-      else
-         // le point PEUT appartenir au segment
-         return (   (operator [] (lPos    ) == pt) 
-                 || (operator [] (lPos + 1) == pt)
-                 || ((lPos > 0) && (operator [] (lPos - 1) == pt))
-                );
-   }
-} // fin de PointInVector
-    
-/*----------------------------------------------------------\
-|                     PointOnLine                           |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Détermine si un point donné appartient à la droite dont  |
-|     ce vecteur est support                                |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-| pt : le point en question                                 |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un booléen                                               |
-\----------------------------------------------------------*/
-bool CVector::PointOnLine (const Point &pt) const
-{
-   // Comme ces classe de vecteur est basée sur une représentation
-   //    pixel, on ne peut pas vérifier que les vecteurs sont colinéaires
-   //    (à cause de la précision)
-   if (Nul ())
-   {
-      return (false);
-   }
-   else
-   {
-      long lPos = PosFromPoint (pt);
-    
-      // seul différence avec PointInVector : on ne vérifie pas les bornes
-      //    vis à vis de lPos
-      return (   (operator [] (lPos    ) == pt) 
-              || (operator [] (lPos + 1) == pt)
-              || ((lPos > 0) && (operator [] (lPos - 1) == pt))
-             );
-   }
-} // fin de PointOnLine
-    
-/*----------------------------------------------------------\
-|                       Angle                               |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne l'angle formé par le vecteur et un point formant|
-|     un vecteur avec le point de départ                    |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pt : le point en question                                |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  l'angle en degrés (sens trigonométrique)                 |
-|     retourne une valeur entre 0 et 180                    |
-\----------------------------------------------------------*/
-double CVector::Angle (const Point &pt) const
-{
-   // calcul du cosinus de l'angle
-   if (Nul () || (pt == m_pt1))
-      return (0.0);
-   else
-   {
-      // produit scalaire : v1.v2 = x1.x2 + y1.y2 = ||v1||.||v2||.cos(ß)
-      CVector v (m_pt1, pt);
-   
-      return (acos ((v * *this) / (Norm () * v.Norm ())) * 180. / M_PI);
-   }
-} // fin de Angle
-    
-/*----------------------------------------------------------\
-|                     Orthogonal                            |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne un vecteur orthogonal au segment débutant au    |
-|  point donné.                                             |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  ptStart : point de départ du vecteur orthogonal, devant  |
-|              appartenir au vecteur source                 |
-|  ptDir   : point donnant la direction du nouveau vecteur  |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un vecteur orthogonal                                    |
-\----------------------------------------------------------*/
-CVector CVector::Orthogonal( const Point &ptStart, const Point &ptDir ) const
-{
-   CVector v;
-    
-   // Le point de départ       doit     appartenir à la droite dont ce vecteur est support
-   // Le point de direction ne doit pas appartenir à la droite dont ce vecteur est support
-   if (   PointOnLine (ptStart)
-       &&  !PointOnLine (ptDir)
-      )
-   {
-      // il suffit d'inverser les coordonnées en X et Y pour obtenir
-      // un vecteur orthogonal
-      v.m_pt1   = ptStart;
-      // si le vecteur est du "bon côté", l'angle entre le nouveau vecteur
-      //    et le point, ne doit pas excéder 90°
-      v.m_pt2.x = ptStart.x - m_lDeltaY;
-      v.m_pt2.y = ptStart.y + m_lDeltaX;
-      v.Update ();  // avant de calculer l'angle
-      if (v.Angle (ptDir) > 90.0)
-      {
-         v.m_pt2.x = ptStart.x + m_lDeltaY;
-         v.m_pt2.y = ptStart.y - m_lDeltaX;
-	 v.Update();
-	 assert( v.Angle( ptDir ) < 90.0 );
-      }
-   }
-    
-   v.Update ();
-   return (v);
-} // fin de Orthogonal
-    
-/*----------------------------------------------------------\
-|                     Orthogonal                            |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne un vecteur orthogonal au segment débutant au    |
-|  point donné.                                             |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  ptStart : point de départ du vecteur orthogonal, devant  |
-|              appartenir au vecteur source                 |
-|  uType   : 0/1 pour indiquer le sens du vecteur           |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  un vecteur orthogonal                                    |
-\----------------------------------------------------------*/
-CVector CVector::Orthogonal( const Point &ptStart, unsigned int uType ) const
-{
-   CVector v;
-    
-   // Le point de départ doit appartenir à la droite dont ce vecteur est support
-   if (PointOnLine (ptStart))
-   {
-      // il suffit d'inverser les coordonnées en X et Y pour obtenir
-      // un vecteur orthogonal
-      v.m_pt1   = ptStart;
-      // NE PAS changer la signification de uType, CEIM::Measure compte dessus
-      if (uType)
-      {
-         v.m_pt2.x = ptStart.x + m_lDeltaY;
-         v.m_pt2.y = ptStart.y - m_lDeltaX;
-      }
-      else
-      {
-         v.m_pt2.x = ptStart.x - m_lDeltaY;
-         v.m_pt2.y = ptStart.y + m_lDeltaX;
-      }
-   }
-   
-   v.Update ();
-   return (v);
-} // fin de Orthogonal
-    
-/*----------------------------------------------------------\
-|                     Projected                             |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Retourne le projeté orthogonal du point sur le vecteur   |
-|  Le point retourné est assuré d'appartenir au vecteur     |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  pt : point à projeter                                    |
-|-----------------------------------------------------------|
-| RETOURNE :                                                |
-|  le projeté orthogonal                                    |
-\----------------------------------------------------------*/
-Point CVector::Projected (const Point &pt) const
-{
-   // Soient A et B les 2 points du vecteur, C le point en paramètre, M le projeté
-   //                                        orthogonal de C sur AB.
-   //
-   // 1° le projeté appartenant au vecteur, il doit appartenir au support
-   //    (Y - Ya)*m_lDeltaX - (X - Xa)*m_lDeltaY = 0
-   // 2° par le produit scalaire on retrouve une équation à 2 inconnues
-   //    (X - Xc)*m_lDeltaX + (Y - Yc)*m_lDeltaY = 0
-   
-   // petite optimisation
-   if (m_lDeltaY == 0)
-      return (Point (pt.x, m_pt1.y));
-   else if (m_lDeltaX == 0)
-      return (Point (m_pt1.x, pt.y));
-   else
-   {
-      // X(1 + SLOPE²) = Yc.SLOPE + Xa.SLOPE² - Ya.SLOPE + Xc
-      // Y             = (X - Xa).SLOPE + Ya
-      double dblSlope = double (m_lDeltaY) / double (m_lDeltaX),
-             dblX,
-             dblY;
-    
-      dblX  = dblSlope * (pt.y + m_pt1.x * dblSlope - m_pt1.y) + pt.x;
-      dblX /= (1 + dblSlope * dblSlope);
-      dblY  = (dblX - m_pt1.x) * dblSlope + m_pt1.y;
-      // suppression de l'erreur induite par l'arrondi
-      // via l'appel à []
-      return (operator [] (PosFromPoint (Point (Double2Long (dblX), Double2Long (dblY)))));
-   }
-} // end of Projected
-    
-/*----------------------------------------------------------\
-|                     SetLength                             |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Impose une longueur au segment à partir du premier point |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  lNewSize : nouvelle taille souhaitée pour le segment     |
-|              signé pour autoriser une inversion du vecteur|
-\----------------------------------------------------------*/
-void CVector::SetLength (long lNewSize)
-{
-   m_pt2 = operator [] (lNewSize);
-   Update ();
-} // fin de SetLength
-    
-/*----------------------------------------------------------\
-|                     Mask                                  |
-|-----------------------------------------------------------|
-| DESCRIPTION :                                             |
-|  Limite l'étendue du vecteur à l'intérieur du rectangle   |
-|-----------------------------------------------------------|
-| PARAMETRES :                                              |
-|  rcLimit : rectangle limitant l'étendue du vecteur        |
-\----------------------------------------------------------*/
-void CVector::Mask (const Rect &rcLimit)
-{
-   // les bords droit et inférieur ne sont pas considérés comme
-   // faisant partie du rectangle
-   // ATTENTION les coordonnées sont croissantes vers le bas
-   long lX1, lY1, lX2, lY2;
-    
-   // à chaque problème, on regarde si l'autre point résoud le 
-   // problème rencontré, si ce n'est pas le cas, il n'y a rien
-   // à faire
-   lX1 = m_pt1.x - rcLimit.left;
-   lX2 = m_pt2.x - rcLimit.left;
-   if (lX1 < 0)
-   {
-      if (lX2 < 0)
-      {
-         // le 2° point est aussi à gauche du bord gauche
-         //NullVector ();
-         return;
-      }
-   }
-   else if (lX1 >= rcLimit.right)
-   {
-   }
-   lY1 = m_pt1.y - rcLimit.top;
-   lY2 = m_pt2.y - rcLimit.top;
-} // fin de Mask
-    
-double CVector::Norm (const CScale *pScale) const
-{
-   if ( pScale )
-   {
-     return (pScale->Valid () ? pScale->Distance (m_pt1, m_pt2) : 0);
-   }
-   
-   return 0.0;
-}
-    
-void CVector::MoveTo (const Point &ptNewStart)
-{
- 	m_pt2 += ptNewStart - m_pt1;
-   	m_pt1  = ptNewStart;
-    // pas la peine d'appeler Update, ce n'est qu'une translation
-}
-
-/*
-                  Quelques tests
-    
-   CVector v1 (CPoint(4,6), CPoint (12,3)),
-           v2;
-   LONG    l;
-    
-   for (l = 0; l <= v1.Length (); l++)
-      afxDump << v1 [l] << "\n";
-   afxDump << v1.PointInVector (CPoint (4, 6))      << "," << v1.PointOnLine (CPoint ( 4, 6)) << "\n";
-   afxDump << v1.PointInVector (CPoint (5, 6))      << "," << v1.PointOnLine (CPoint ( 5, 6)) << "\n";
-   afxDump << v1.PointInVector (CPoint (11,4))      << "," << v1.PointOnLine (CPoint (11, 4)) << "\n";
-   afxDump << v1.PointInVector (CPoint (15,2))      << "," << v1.PointOnLine (CPoint (15, 2)) << "\n";
-   afxDump << v1.PointInVector (CPoint (0, 7))      << "," << v1.PointOnLine (CPoint ( 0, 7)) << "\n";
-   afxDump << v1.PointInVector (CPoint (-120,300))  << "," << v1.PointOnLine (CPoint (-120,300)) << "\n";
- 
-   v1.SetLength (v1.Length () * 2);
-   for (;l <= v1.Length (); l++)
-      afxDump << v1 [l] << "\n";
-   afxDump << v1.PointInVector (CPoint (4, 6))      << "," << v1.PointOnLine (CPoint ( 4, 6)) << "\n";
-   afxDump << v1.PointInVector (CPoint (5, 6))      << "," << v1.PointOnLine (CPoint ( 5, 6)) << "\n";
-   afxDump << v1.PointInVector (CPoint (11,4))      << "," << v1.PointOnLine (CPoint (11, 4)) << "\n";
-   afxDump << v1.PointInVector (CPoint (15,2))      << "," << v1.PointOnLine (CPoint (15, 2)) << "\n";
-   afxDump << v1.PointInVector (CPoint (0, 7))      << "," << v1.PointOnLine (CPoint ( 0, 7)) << "\n";
-   afxDump << v1.PointInVector (CPoint (-120,300))  << "," << v1.PointOnLine (CPoint (-120,300)) << "\n";
-    
-   // vérification du premier sens
-   v2 = v1.Orthogonal (v1.StartPoint (), CPoint (10,7));
-   for (l = 0; l <= v2.Length (); l++)
-      afxDump << v2 [l] << "\n";
-    
-   v2 = v1.Orthogonal (v1.StartPoint (), CPoint (2,8));
-   for (l = 0; l <= v2.Length (); l++)
-      afxDump << v2 [l] << "\n";
-    
-   // vérification du sens opposé
-   v2 = v1.Orthogonal (v1.StartPoint (), CPoint (9,4)); // aussi près que possible du vecteur source
-   for (l = 0; l <= v2.Length (); l++)
-      afxDump << v2 [l] << "\n";
-    
-   v2 = v1.Orthogonal (v1.StartPoint (), CPoint (0,6));
-   for (l = 0; l <= v2.Length (); l++)
-      afxDump << v2 [l] << "\n";
-*/
-

api.ipsocloud.com/math.backup/imt/vector.h

@@ -1,64 +0,0 @@
-#pragma once
-
-
-#include "point.h"
-#include "rectangle.h"
-
-
-class CScale;
-    
-class CVector
-{
-  public:
-  
-    void Update (void); // mise à jour des variables membres lorsque l'un des points
-                        // du vecteur est modifie
-
-    Point m_pt1, // premier  point du vecteur (pour l'orientation)
-          m_pt2; // deuxieme point du vecteur
-    long m_dwSize; // nombre de points requis pour tracer une droite continue
-    CVector(void);
-    CVector(const Point &, const Point &);
-    CVector(int, int, int, int);
-    inline CVector(const CVector &vSource) { *this = vSource; };
-    	
-    Point operator [] (long) const;
-    const CVector &operator = (const CVector & );
-    inline long operator * (const CVector &v) const { return (v.m_lDeltaX * m_lDeltaX) + (v.m_lDeltaY * m_lDeltaY); }
-    	
-    inline long Length(void) const { return (m_dwSize); };// = max(dx, dy) = (dx^n+dy^n)^(1/n) avec n=infini (distance euclidienne n=2, distance de manhatan n=1) [JAK - 21/1/2003]
-    inline bool Nul(void) const { return (m_dwSize == 0);  };
-    inline const Point& StartPoint(void) const { return (m_pt1); };
-    inline const Point& EndPoint(void) const { return (m_pt2); };
-    inline void SetStartPoint(const Point &pt) { m_pt1 = pt; Update (); };
-    inline void SetEndPoint(const Point &pt) { m_pt2 = pt; Update (); };
-    inline void OffsetVector(long x, long y) { m_pt1.Offset (x, y); m_pt2.Offset (x, y); }
-    inline double Norm(void) const { return (m_dblNorm); };
-    double Norm(const CScale*) const;
-    bool PointInVector(const Point &) const;
-    bool PointOnLine(const Point &) const;
-    double Angle(const Point &) const;
-    CVector Orthogonal(const Point &, const Point &) const; // vecteur orthogonal partant du 1er point vers le 2eme point
-    CVector Orthogonal(const Point &, unsigned int) const; // vecteur orthogonal partant du point dans le sens donne
-    // vecteur orthogonal par le projete orthogonal du point sur le vecteur
-    inline CVector  Orthogonal (const Point &pt) const { return CVector(Projected(pt), pt); }
-    Point Projected(const Point &) const; // projete orthogonal du point sur le vecteur
-    	
-    void SetLength(long);
-    void Mask(const Rect &);
-    long PosFromPoint(const Point &) const; // retourne la position ESTIMEE d'un point sur
-                                            // la droite. Cela ne veut pas dire qu'il
-                                            // fait partie de la droite
-    	
-    void MoveTo(const Point &ptNewStart);
-    	
-    // Deplace
-    bool m_fHorizontal; // variations horizontale/verticale la moins importante
-    	
-  protected:
-  
-    long m_lDeltaX; // variation en abscisse
-    long m_lDeltaY; // variation en ordonnee
-    double m_dblNorm; // norme du vecteur en pixels
-}; 
-    

api.ipsocloud.com/math.backup/main.cpp

@@ -1,131 +0,0 @@
-#include <QCoreApplication>
-#include <QImage>
-#include <QJsonObject>
-#include <QJsonArray>
-#include <QJsonDocument>
-
-#include <imt/EIMBase.h>
-#include <imt/EIMResult.h>
-#include <imt/CEIMResult.h>
-#include <imt/scale.h>
-
-#include <iostream>
-using namespace std;
-
-const CScale *g_pCurrentScale;
-
-// ./math -platform offscreen -image=../storage/media/15/a0fd44eb-8174-4d8b-bc76-690bc6e441b3.jpeg -metric=0.3x0.3 -point1=280x259 -point2=411x255
-
-int main(int argc, char *argv[])
-{
-    QCoreApplication app(argc, argv);
-
-    QImage image;
-    double pixelWidth = 0, pixelHeight = 0;
-    Point m_p0, m_p1;
-
-    // parse cmd line
-    foreach(QString arg, QCoreApplication::arguments()) {
-        if(arg.startsWith("-image=")) {
-            QString path = arg.replace("-image=", "");
-            if(!image.load(path)) {
-                return -2;
-            }
-        }
-        else if(arg.startsWith("-metric=")) {
-            QStringList metric = arg.replace("-metric=", "").split("x");
-            if(metric.size()==2) {
-                pixelWidth = metric[0].toDouble();
-                pixelHeight = metric[1].toDouble();
-            }
-            else {
-                return -1;
-            }
-        }
-        else if(arg.startsWith("-point1=")) {
-            QStringList point = arg.replace("-point1=", "").split("x");
-            if(point.size()==2) {
-                m_p0.x = point[0].toInt();
-                m_p0.y = point[1].toInt();
-            }
-            else {
-                return -4;
-            }
-        }
-        else if(arg.startsWith("-point2=")) {
-            QStringList point = arg.replace("-point2=", "").split("x");
-            if(point.size()==2) {
-                m_p1.x = point[0].toInt();
-                m_p1.y = point[1].toInt();
-            }
-            else {
-                return -5;
-            }
-        }
-    }
-    if(image.isNull() || pixelWidth==0.0 || pixelWidth==0.0) {
-        return -3;
-    }
-
-    //std::cout << image.width() << "x" << image.height() << std::endl;
-    //std::cout << pixelWidth << "x" << pixelHeight << std::endl;
-
-    g_pCurrentScale = new CScale("DLL scale", pixelWidth, pixelHeight);
-
-    CEIMResult result;
-
-    CEIMBase ceim;
-    ceim.SetEimAssisted( true );
-    bool status = ceim.Measure(&image, m_p0, m_p1, false, &result);
-
-    result.result->p0.x = m_p0.x;
-    result.result->p0.y = m_p0.y;
-    result.result->p1.x = m_p1.x;
-    result.result->p1.y = m_p1.y;
-    result.result->distance = g_pCurrentScale->Distance( result.result->numberOfPoints );
-
-    imt::IMTResult result2;
-    status |= result.fill( &result2 );
-
-    if(status) {
-        QJsonObject data;
-        data["nearWall"] = ceim.m_bNearWall;
-        data["imt_max"] = result2.imt_max;
-        data["imt_mean"] = result2.imt_mean;
-        data["imt_stddev"] = result2.imt_standardDeviation;
-        data["intima_mean"] = result2.intima_mean;
-        data["media_mean"] = result2.media_mean;
-        data["qualityIndex"] = result2.qualityIndex;
-        data["distance"] = result2.distance;
-        data["numberOfPoints"] = result2.numberOfPoints;
-        QJsonArray vect_intima;
-        QJsonArray vect_media;
-        QJsonArray vect_adventitia;
-        QJsonObject point;
-        for (int i=0; i<result2.numberOfPoints; i++) {
-            if(result2.vect_intima[i].x>0) {
-                point["x"] = result2.vect_intima[i].x;
-                point["y"] = result2.vect_intima[i].y;
-                vect_intima.append(point);
-            }
-            if(result2.vect_media[i].x>0) {
-                point["x"] = result2.vect_media[i].x;
-                point["y"] = result2.vect_media[i].y;
-                vect_media.append(point);
-            }
-            if(result2.vect_adventitia[i].x>0) {
-                point["x"] = result2.vect_adventitia[i].x;
-                point["y"] = result2.vect_adventitia[i].y;
-                vect_adventitia.append(point);
-            }
-        }
-        data["vect_intima"] = vect_intima;
-        data["vect_media"] = vect_media;
-        data["vect_adventitia"] = vect_adventitia;
-
-        QString json = QJsonDocument(data).toJson(QJsonDocument::Compact);
-        std::cout << json.toStdString() << std::endl;
-    }
-
-    return 0;
-}

api.ipsocloud.com/math.backup/math.pro

@@ -1,44 +0,0 @@
-QT += gui
-
-CONFIG += c++11 console
-CONFIG -= app_bundle
-
-# The following define makes your compiler emit warnings if you use
-# any Qt feature that has been marked deprecated (the exact warnings
-# depend on your compiler). Please consult the documentation of the
-# deprecated API in order to know how to port your code away from it.
-DEFINES += QT_DEPRECATED_WARNINGS
-
-# You can also make your code fail to compile if it uses deprecated APIs.
-# In order to do so, uncomment the following line.
-# You can also select to disable deprecated APIs only up to a certain version of Qt.
-#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
-
-SOURCES += \
-    imt/CEIMResult.cpp \
-    imt/EIMBase.cpp \
-    imt/MeanEstimate.cpp \
-    imt/point.cpp \
-    imt/rectangle.cpp \
-    imt/scale.cpp \
-    imt/ToolsMath.cpp \
-    imt/vector.cpp \
-    main.cpp
-
-# Default rules for deployment.
-qnx: target.path = /tmp/$${TARGET}/bin
-else: unix:!android: target.path = /opt/$${TARGET}/bin
-!isEmpty(target.path): INSTALLS += target
-
-HEADERS += \
-    imt/CEIMInfo.h \
-    imt/CEIMResult.h \
-    imt/EIMBase.h \
-    imt/EIMResult.h \
-    imt/MeanEstimate.h \
-    imt/point.h \
-    imt/rectangle.h \
-    imt/Ressource.h \
-    imt/scale.h \
-    imt/ToolsMath.h \
-    imt/vector.h

api.ipsocloud.com/sql/localhost.sql

@@ -1,606 +0,0 @@
--- Adminer 4.7.1 MySQL dump
-
-SET NAMES utf8;
-SET time_zone = '+00:00';
-SET foreign_key_checks = 0;
-SET sql_mode = 'NO_AUTO_VALUE_ON_ZERO';
-
-
-
-CREATE DATABASE `iimt_mathcloud` /*!40100 DEFAULT CHARACTER SET utf8 */;
-USE `iimt_mathcloud`;
-
-SET NAMES utf8mb4;
-
-DROP TABLE IF EXISTS `abacus`;
-CREATE TABLE `abacus` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `name` text NOT NULL,
-  `sex` varchar(1) NOT NULL,
-  `race` varchar(128) NOT NULL,
-  `side` varchar(16) NOT NULL,
-  `data` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-INSERT INTO `abacus` (`ID`, `name`, `sex`, `race`, `side`, `data`) VALUES
-(1,	'Europe, France, 30-79 years, PARC 2009 (Mean)',	'M',	'',	'',	'[{\r\n\"age\":30,\r\n\"min\":0.574,\r\n\"mean\":0.616,\r\n\"max\":0.672\r\n},{\r\n\"age\":40,\r\n\"min\":0.586,\r\n\"mean\":0.653,\r\n\"max\":0.705\r\n},{\r\n\"age\":50,\r\n\"min\":0.637,\r\n\"mean\":0.701,\r\n\"max\":0.787\r\n},{\r\n\"age\":60,\r\n\"min\":0.663,\r\n\"mean\":0.738,\r\n\"max\":0.842\r\n},{\r\n\"age\":70,\r\n\"min\":0.743,\r\n\"mean\":0.798,\r\n\"max\":0.907\r\n}]\r\n'),
-(2,	'Europe, France, 30-79 years, PARC 2009 (Mean)',	'F',	'',	'',	'[{\r\n\"age\":30,\r\n\"min\":0.537,\r\n\"mean\":0.588,\r\n\"max\":0.635\r\n},{\r\n\"age\":40,\r\n\"min\":0.576,\r\n\"mean\":0.64,\r\n\"max\":0.691\r\n},{\r\n\"age\":50,\r\n\"min\":0.619,\r\n\"mean\":0.669,\r\n\"max\":0.737\r\n},{\r\n\"age\":60,\r\n\"min\":0.665,\r\n\"mean\":0.752,\r\n\"max\":0.817\r\n},{\r\n\"age\":70,\r\n\"min\":0.71,\r\n\"mean\":0.758,\r\n\"max\":0.841\r\n}]\r\n'),
-(3,	'USA, 35-85 years, Caucasian, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'M',	'white',	'right',	'[{\r\n\"age\":35,\r\n\"min\":0.43,\r\n\"mean\":0.48,\r\n\"max\":0.55\r\n},{\r\n\"age\":45,\r\n\"min\":0.50,\r\n\"mean\":0.57,\r\n\"max\":0.66\r\n},{\r\n\"age\":55,\r\n\"min\":0.57,\r\n\"mean\":0.66,\r\n\"max\":0.77\r\n},{\r\n\"age\":65,\r\n\"min\":0.65,\r\n\"mean\":0.76,\r\n\"max\":0.90\r\n},{\r\n\"age\":75,\r\n\"min\":0.73,\r\n\"mean\":0.86,\r\n\"max\":1.03\r\n},{\r\n\"age\":85,\r\n\"min\":0.80,\r\n\"mean\":0.95,\r\n\"max\":1.14\r\n}]\r\n'),
-(4,	'USA, 35-85 years, Caucasian, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'M',	'white',	'left',	'[{\r\n\"age\":35,\r\n\"min\":0.45,\r\n\"mean\":0.520,\r\n\"max\":0.6\r\n},{\r\n\"age\":45,\r\n\"min\":0.52,\r\n\"mean\":0.6,\r\n\"max\":0.7\r\n},{\r\n\"age\":55,\r\n\"min\":0.59,\r\n\"mean\":0.68,\r\n\"max\":0.8\r\n},{\r\n\"age\":65,\r\n\"min\":0.65,\r\n\"mean\":0.77,\r\n\"max\":0.93\r\n},{\r\n\"age\":75,\r\n\"min\":0.71,\r\n\"mean\":0.86,\r\n\"max\":1.06\r\n},{\r\n\"age\":85,\r\n\"min\":0.78,\r\n\"mean\":0.97,\r\n\"max\":1.18\r\n}]\r\n'),
-(5,	'USA, 35-85 years, Caucasian, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'F',	'white',	'right',	'[{\r\n\"age\":35,\r\n\"min\":0.39,\r\n\"mean\":0.44,\r\n\"max\":0.51\r\n},{\r\n\"age\":45,\r\n\"min\":0.47,\r\n\"mean\":0.53,\r\n\"max\":0.61\r\n},{\r\n\"age\":55,\r\n\"min\":0.55,\r\n\"mean\":0.62,\r\n\"max\":0.71\r\n},{\r\n\"age\":65,\r\n\"min\":0.6,\r\n\"mean\":0.69,\r\n\"max\":0.81\r\n},{\r\n\"age\":75,\r\n\"min\":0.65,\r\n\"mean\":0.76,\r\n\"max\":0.91\r\n},{\r\n\"age\":85,\r\n\"min\":0.72,\r\n\"mean\":0.88,\r\n\"max\":1.01\r\n}]\r\n'),
-(6,	'USA, 35-85 years, Caucasian, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'F',	'white',	'left',	'[{\r\n\"age\":35,\r\n\"min\":0.4,\r\n\"mean\":0.46,\r\n\"max\":0.51\r\n},{\r\n\"age\":45,\r\n\"min\":0.47,\r\n\"mean\":0.54,\r\n\"max\":0.61\r\n},{\r\n\"age\":55,\r\n\"min\":0.54,\r\n\"mean\":0.62,\r\n\"max\":0.71\r\n},{\r\n\"age\":65,\r\n\"min\":0.61,\r\n\"mean\":0.71,\r\n\"max\":0.81\r\n},{\r\n\"age\":75,\r\n\"min\":0.68,\r\n\"mean\":0.8,\r\n\"max\":0.91\r\n},{\r\n\"age\":85,\r\n\"min\":0.74,\r\n\"mean\":0.84,\r\n\"max\":1.01\r\n}]\r\n'),
-(7,	'USA, 35-85 years, African American, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'M',	'african',	'right',	'[{\r\n\"age\":35,\r\n\"min\":0.43,\r\n\"mean\":0.5,\r\n\"max\":0.58\r\n},{\r\n\"age\":45,\r\n\"min\":0.52,\r\n\"mean\":0.61,\r\n\"max\":0.71\r\n},{\r\n\"age\":55,\r\n\"min\":0.61,\r\n\"mean\":0.72,\r\n\"max\":0.84\r\n},{\r\n\"age\":65,\r\n\"min\":0.72,\r\n\"mean\":0.85,\r\n\"max\":1.01\r\n},{\r\n\"age\":75,\r\n\"min\":0.83,\r\n\"mean\":0.98,\r\n\"max\":1.14\r\n},{\r\n\"age\":85,\r\n\"min\":0.94,\r\n\"mean\":1.06,\r\n\"max\":1.28\r\n}]\r\n'),
-(8,	'USA, 35-85 years, African American, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'M',	'african',	'left',	'[{\r\n\"age\":35,\r\n\"min\":0.45,\r\n\"mean\":0.53,\r\n\"max\":0.61\r\n},{\r\n\"age\":45,\r\n\"min\":0.53,\r\n\"mean\":0.62,\r\n\"max\":0.72\r\n},{\r\n\"age\":55,\r\n\"min\":0.61,\r\n\"mean\":0.71,\r\n\"max\":0.83\r\n},{\r\n\"age\":65,\r\n\"min\":0.69,\r\n\"mean\":0.82,\r\n\"max\":0.99\r\n},{\r\n\"age\":75,\r\n\"min\":0.77,\r\n\"mean\":0.93,\r\n\"max\":1.16\r\n},{\r\n\"age\":85,\r\n\"min\":0.94,\r\n\"mean\":1.10,\r\n\"max\":1.36\r\n}]\r\n'),
-(9,	'USA, 35-85 years, African American, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'F',	'african',	'right',	'[{\r\n\"age\":35,\r\n\"min\":0.43,\r\n\"mean\":0.48,\r\n\"max\":0.52\r\n},{\r\n\"age\":45,\r\n\"min\":0.51,\r\n\"mean\":0.58,\r\n\"max\":0.65\r\n},{\r\n\"age\":55,\r\n\"min\":0.59,\r\n\"mean\":0.68,\r\n\"max\":0.78\r\n},{\r\n\"age\":65,\r\n\"min\":0.63,\r\n\"mean\":0.74,\r\n\"max\":0.85\r\n},{\r\n\"age\":75,\r\n\"min\":0.67,\r\n\"mean\":0.8,\r\n\"max\":0.92\r\n},{\r\n\"age\":85,\r\n\"min\":0.74,\r\n\"mean\":0.9,\r\n\"max\":1.06\r\n}]\r\n'),
-(10,	'USA, 35-85 years, African American, ARIC 1993 (R+L). Extrapolated values below 45 and over 65',	'F',	'african',	'left',	'[{\r\n\"age\":35,\r\n\"min\":0.42,\r\n\"mean\":0.47,\r\n\"max\":0.53\r\n},{\r\n\"age\":45,\r\n\"min\":0.49,\r\n\"mean\":0.56,\r\n\"max\":0.64\r\n},{\r\n\"age\":55,\r\n\"min\":0.56,\r\n\"mean\":0.65,\r\n\"max\":0.75\r\n},{\r\n\"age\":65,\r\n\"min\":0.62,\r\n\"mean\":0.72,\r\n\"max\":0.85\r\n},{\r\n\"age\":75,\r\n\"min\":0.68,\r\n\"mean\":0.79,\r\n\"max\":0.95\r\n},{\r\n\"age\":85,\r\n\"min\":0.78,\r\n\"mean\":0.86,\r\n\"max\":1.06\r\n}]\r\n');
-
-DROP TABLE IF EXISTS `broker`;
-CREATE TABLE `broker` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `name` varchar(64) NOT NULL,
-  `config` text NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-INSERT INTO `broker` (`ID`, `name`, `config`) VALUES
-(1,	'braintree-sandbox',	'{\r\n \"MerchantID\": \"tqbv9j5p3fmbmzx4\",\r\n \"PublicKey\": \"vsyr2294699hj6z5\",\r\n \"PrivateKey\": \"70184b99b13aafb398827f4702e2648a\"\r\n}');
-
-DROP TABLE IF EXISTS `clinical_trial`;
-CREATE TABLE `clinical_trial` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `number` varchar(64) NOT NULL,
-  `name` text NOT NULL,
-  `start` date NOT NULL,
-  `patient_expected` smallint(6) NOT NULL,
-  `center_count` tinyint(4) NOT NULL,
-  `inclusion_month` tinyint(4) NOT NULL,
-  `followup_month` tinyint(4) NOT NULL,
-  `visit_per_patient` tinyint(4) NOT NULL,
-  `visit_interval` tinyint(4) NOT NULL,
-  `image_per_visit` tinyint(4) NOT NULL,
-  `video_per_visit` tinyint(4) NOT NULL,
-  `measure_per_timepoint` tinyint(4) NOT NULL,
-  `comment` text NOT NULL,
-  `max_readers` tinyint(4) NOT NULL,
-  `max_investigators` tinyint(4) NOT NULL,
-  `anon_percent` smallint(6) NOT NULL,
-  `fk_user` int(255) NOT NULL,
-  `created` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `context`;
-CREATE TABLE `context` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `fk_visit` int(255) NOT NULL,
-  `risks` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL DEFAULT '{}',
-  `phistory` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL DEFAULT '{}',
-  `fhistory` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL DEFAULT '{}',
-  `examination` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL DEFAULT '{}',
-  `treatments` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `country`;
-CREATE TABLE `country` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `alpha2` varchar(2) NOT NULL,
-  `alpha3` varchar(3) NOT NULL,
-  `name_en` char(128) NOT NULL,
-  `name_fr` char(128) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-INSERT INTO `country` (`ID`, `alpha2`, `alpha3`, `name_en`, `name_fr`) VALUES
-(1,	'AE',	'ARE',	'United Arab Emirates',	'Emirats Arabes Unis'),
-(2,	'AF',	'AFG',	'Afghanistan',	'Afghanistan'),
-(3,	'AG',	'ATG',	'Antigua and Barbuda',	'Antigua-et-Barbuda'),
-(4,	'AI',	'AIA',	'Anguilla',	'Anguilla'),
-(5,	'AL',	'ALB',	'Albania',	'Albanie'),
-(6,	'AM',	'ARM',	'Armenia',	'Arménie'),
-(7,	'AN',	'ANT',	'Netherlands Antilles',	'Antilles néerlandaises'),
-(8,	'AO',	'AGO',	'Angola',	'Angola'),
-(9,	'AQ',	'ATA',	'Antarctica',	'Antarctique'),
-(10,	'AR',	'ARG',	'Argentina',	'Argentine'),
-(11,	'AS',	'ASM',	'American Samoa',	'Samoa américaines'),
-(12,	'AT',	'AUT',	'Austria',	'Autriche'),
-(13,	'AU',	'AUS',	'Australia',	'Australie'),
-(14,	'AW',	'ABW',	'Aruba',	'Aruba'),
-(15,	'AZ',	'AZE',	'Azerbaijan',	'Azerbaïdjan'),
-(16,	'BA',	'BIH',	'Bosnia and Herzegovina',	'Bosnie Herzégovine'),
-(17,	'BB',	'BRB',	'Barbados',	'Barbade'),
-(18,	'BD',	'BGD',	'Bangladesh',	'Bangladesh'),
-(19,	'BE',	'BEL',	'Belgium',	'Belgique'),
-(20,	'BF',	'BFA',	'Burkina Faso',	'Burkina Faso'),
-(21,	'BG',	'BGR',	'Bulgaria',	'Bulgarie'),
-(22,	'BH',	'BHR',	'Bahrain',	'Bahreïn'),
-(23,	'BI',	'BDI',	'Burundi',	'Burundi'),
-(24,	'BJ',	'BEN',	'Benin',	'Bénin'),
-(25,	'BM',	'BMU',	'Bermuda',	'Bermudes'),
-(26,	'BN',	'BRN',	'Brunei',	'Brunei'),
-(27,	'BO',	'BOL',	'Bolivia',	'Bolivie'),
-(28,	'BR',	'BRA',	'Brazil',	'Brésil'),
-(29,	'BS',	'BHS',	'Bahamas',	'Bahamas'),
-(30,	'BT',	'BTN',	'Bhutan',	'Bhoutan'),
-(31,	'BV',	'BVT',	'Bouvet Island',	'Île Bouvet'),
-(32,	'BW',	'BWA',	'Botswana',	'Botswana'),
-(33,	'BY',	'BLR',	'Belarus',	'Biélorussie'),
-(34,	'BZ',	'BLZ',	'Belize',	'Belize'),
-(35,	'CA',	'CAN',	'Canada',	'Canada'),
-(36,	'CC',	'CCK',	'Cocos (Keeling) Islands',	'Îles Cocos (Keeling)'),
-(37,	'CD',	'COD',	'Congo, The Democratic Republic of the',	'Congo, République démocratique du'),
-(38,	'CF',	'CAF',	'Central African Republic',	'République centrafricaine'),
-(39,	'CG',	'COG',	'Congo',	'Congo'),
-(40,	'CH',	'CHE',	'Switzerland',	'Suisse'),
-(41,	'CI',	'CIV',	'Côte d\'Ivoire',	'Côte Ivoire'),
-(42,	'CK',	'COK',	'Cook Islands',	'Îles Cook'),
-(43,	'CL',	'CHL',	'Chile',	'Chili'),
-(44,	'CM',	'CMR',	'Cameroon',	'Cameroun'),
-(45,	'CN',	'CHN',	'China',	'Chine'),
-(46,	'CO',	'COL',	'Colombia',	'Colombie'),
-(47,	'CR',	'CRI',	'Costa Rica',	'Costa Rica'),
-(48,	'CU',	'CUB',	'Cuba',	'Cuba'),
-(49,	'CV',	'CPV',	'Cape Verde',	'Cap-Vert'),
-(50,	'CX',	'CXR',	'Christmas Island',	'île de noël'),
-(51,	'CY',	'CYP',	'Cyprus',	'Chypre'),
-(52,	'CZ',	'CZE',	'Czech Republic',	'République Tchèque'),
-(53,	'DE',	'DEU',	'Germany',	'Allemagne'),
-(54,	'DJ',	'DJI',	'Djibouti',	'Djibouti'),
-(55,	'DK',	'DNK',	'Denmark',	'Danemark'),
-(56,	'DM',	'DMA',	'Dominica',	'Dominique'),
-(57,	'DO',	'DOM',	'Dominican Republic',	'République Dominicaine'),
-(58,	'DZ',	'DZA',	'Algeria',	'Algérie'),
-(59,	'EC',	'ECU',	'Ecuador',	'Equateur'),
-(60,	'EE',	'EST',	'Estonia',	'Estonie'),
-(61,	'EG',	'EGY',	'Egypt',	'Egypte'),
-(62,	'EH',	'ESH',	'Western Sahara',	'Sahara occidental'),
-(63,	'ER',	'ERI',	'Eritrea',	'Érythrée'),
-(64,	'ES',	'ESP',	'Spain',	'Espagne'),
-(65,	'ET',	'ETH',	'Ethiopia',	'Ethiopie'),
-(66,	'FI',	'FIN',	'Finland',	'Finlande'),
-(67,	'FJ',	'FJI',	'Fiji Islands',	'Iles Fidji'),
-(68,	'FK',	'FLK',	'Falkland Islands',	'îles Falkland'),
-(69,	'FM',	'FSM',	'Micronesia, Federated States of',	'Micronésie, États fédérés de'),
-(70,	'FO',	'FRO',	'Faroe Islands',	'Îles Féroé'),
-(71,	'FR',	'FRA',	'France',	'France'),
-(72,	'GA',	'GAB',	'Gabon',	'Gabon'),
-(73,	'GB',	'GBR',	'United Kingdom',	'Royaume-Uni'),
-(74,	'GD',	'GRD',	'Grenada',	'Grenade'),
-(75,	'GE',	'GEO',	'Georgia',	'Géorgie'),
-(76,	'GF',	'GUF',	'French Guiana',	'Guyane Française'),
-(77,	'GH',	'GHA',	'Ghana',	'Ghana'),
-(78,	'GI',	'GIB',	'Gibraltar',	'Gibraltar'),
-(79,	'GL',	'GRL',	'Greenland',	'Groenland'),
-(80,	'GM',	'GMB',	'Gambia',	'Gambie'),
-(81,	'GN',	'GIN',	'Guinea',	'Guinée'),
-(82,	'GP',	'GLP',	'Guadeloupe',	'Guadeloupe'),
-(83,	'GQ',	'GNQ',	'Equatorial Guinea',	'Guinée Équatoriale'),
-(84,	'GR',	'GRC',	'Greece',	'Grèce'),
-(85,	'GS',	'SGS',	'South Georgia and the South Sandwich Islands',	'Géorgie du Sud et îles Sandwich du Sud'),
-(86,	'GT',	'GTM',	'Guatemala',	'Guatemala'),
-(87,	'GU',	'GUM',	'Guam',	'Guam'),
-(88,	'GW',	'GNB',	'Guinea-Bissau',	'Guinée-Bissau'),
-(89,	'GY',	'GUY',	'Guyana',	'Guyane'),
-(90,	'HK',	'HKG',	'Hong Kong',	'Hong Kong'),
-(91,	'HM',	'HMD',	'Heard Island and McDonald Islands',	'Îles Heard et McDonald'),
-(92,	'HN',	'HND',	'Honduras',	'Honduras'),
-(93,	'HR',	'HRV',	'Croatia',	'Croatie'),
-(94,	'HT',	'HTI',	'Haiti',	'Haïti'),
-(95,	'HU',	'HUN',	'Hungary',	'Hongrie'),
-(96,	'ID',	'IDN',	'Indonesia',	'Indonésie'),
-(97,	'IE',	'IRL',	'Ireland',	'Irlande'),
-(98,	'IL',	'ISR',	'Israel',	'Israël'),
-(99,	'IN',	'IND',	'India',	'Inde'),
-(100,	'IO',	'IOT',	'British Indian Ocean Territory',	'Territoire britannique de l\'océan Indien'),
-(101,	'IQ',	'IRQ',	'Iraq',	'Irak'),
-(102,	'IR',	'IRN',	'Iran',	'Iran'),
-(103,	'IS',	'ISL',	'Iceland',	'Islande'),
-(104,	'IT',	'ITA',	'Italy',	'Italie'),
-(105,	'JM',	'JAM',	'Jamaica',	'Jamaïque'),
-(106,	'JO',	'JOR',	'Jordan',	'Jordan'),
-(107,	'JP',	'JPN',	'Japan',	'Japon'),
-(108,	'KE',	'KEN',	'Kenya',	'Kenya'),
-(109,	'KG',	'KGZ',	'Kyrgyzstan',	'Kirghizistan'),
-(110,	'KH',	'KHM',	'Cambodia',	'Cambodge'),
-(111,	'KI',	'KIR',	'Kiribati',	'Kiribati'),
-(112,	'KM',	'COM',	'Comoros',	'Comores'),
-(113,	'KN',	'KNA',	'Saint Kitts and Nevis',	'Saint-Christophe-et-Niévès'),
-(114,	'KP',	'PRK',	'North Korea',	'Corée du Nord'),
-(115,	'KR',	'KOR',	'South Korea',	'Corée du Sud'),
-(116,	'KW',	'KWT',	'Kuwait',	'Koweit'),
-(117,	'KY',	'CYM',	'Cayman Islands',	'Îles Caïmans'),
-(118,	'KZ',	'KAZ',	'Kazakstan',	'Kazakstan'),
-(119,	'LA',	'LAO',	'Laos',	'Laos'),
-(120,	'LB',	'LBN',	'Lebanon',	'Liban'),
-(121,	'LC',	'LCA',	'Saint Lucia',	'Sainte-Lucie'),
-(122,	'LI',	'LIE',	'Liechtenstein',	'Liechtenstein'),
-(123,	'LK',	'LKA',	'Sri Lanka',	'Sri Lanka'),
-(124,	'LR',	'LBR',	'Liberia',	'Libéria'),
-(125,	'LS',	'LSO',	'Lesotho',	'Lesotho'),
-(126,	'LT',	'LTU',	'Lithuania',	'Lituanie'),
-(127,	'LU',	'LUX',	'Luxembourg',	'Luxembourg'),
-(128,	'LV',	'LVA',	'Latvia',	'Lettonie'),
-(129,	'LY',	'LBY',	'Libyan Arab Jamahiriya',	'Jamahiriya arabe libyenne'),
-(130,	'MA',	'MAR',	'Morocco',	'Maroc'),
-(131,	'MC',	'MCO',	'Monaco',	'Monaco'),
-(132,	'MD',	'MDA',	'Moldova',	'Moldavie'),
-(133,	'MG',	'MDG',	'Madagascar',	'Madagascar'),
-(134,	'MH',	'MHL',	'Marshall Islands',	'Iles Marshall'),
-(135,	'MK',	'MKD',	'Macedonia',	'Macédoine'),
-(136,	'ML',	'MLI',	'Mali',	'Mali'),
-(137,	'MM',	'MMR',	'Myanmar',	'Myanmar'),
-(138,	'MN',	'MNG',	'Mongolia',	'Mongolie'),
-(139,	'MO',	'MAC',	'Macao',	'Macao'),
-(140,	'MP',	'MNP',	'Northern Mariana Islands',	'Îles Mariannes du Nord'),
-(141,	'MQ',	'MTQ',	'Martinique',	'Martinique'),
-(142,	'MR',	'MRT',	'Mauritania',	'Mauritanie'),
-(143,	'MS',	'MSR',	'Montserrat',	'Montserrat'),
-(144,	'MT',	'MLT',	'Malta',	'Malte'),
-(145,	'MU',	'MUS',	'Mauritius',	'Ile Maurice'),
-(146,	'MV',	'MDV',	'Maldives',	'Maldives'),
-(147,	'MW',	'MWI',	'Malawi',	'Malawi'),
-(148,	'MX',	'MEX',	'Mexico',	'Mexique'),
-(149,	'MY',	'MYS',	'Malaysia',	'Malaisie'),
-(150,	'MZ',	'MOZ',	'Mozambique',	'Mozambique'),
-(151,	'NA',	'NAM',	'Namibia',	'Namibie'),
-(152,	'NC',	'NCL',	'New Caledonia',	'Nouvelle Calédonie'),
-(153,	'NE',	'NER',	'Niger',	'Niger'),
-(154,	'NF',	'NFK',	'Norfolk Island',	'Ile de Norfolk'),
-(155,	'NG',	'NGA',	'Nigeria',	'Nigeria'),
-(156,	'NI',	'NIC',	'Nicaragua',	'Nicaragua'),
-(157,	'NL',	'NLD',	'Netherlands',	'Pays-Bas'),
-(158,	'NO',	'NOR',	'Norway',	'Norvège'),
-(159,	'NP',	'NPL',	'Nepal',	'Népal'),
-(160,	'NR',	'NRU',	'Nauru',	'Nauru'),
-(161,	'NU',	'NIU',	'Niue',	'Niue'),
-(162,	'NZ',	'NZL',	'New Zealand',	'Nouvelle-Zélande'),
-(163,	'OM',	'OMN',	'Oman',	'Oman'),
-(164,	'PA',	'PAN',	'Panama',	'Panama'),
-(165,	'PE',	'PER',	'Peru',	'Pérou'),
-(166,	'PF',	'PYF',	'French Polynesia',	'Polynésie française'),
-(167,	'PG',	'PNG',	'Papua New Guinea',	'Papouasie Nouvelle Guinée'),
-(168,	'PH',	'PHL',	'Philippines',	'Philippines'),
-(169,	'PK',	'PAK',	'Pakistan',	'Pakistan'),
-(170,	'PL',	'POL',	'Poland',	'Pologne'),
-(171,	'PM',	'SPM',	'Saint Pierre and Miquelon',	'Saint-Pierre-et-Miquelon'),
-(172,	'PN',	'PCN',	'Pitcairn',	'Pitcairn'),
-(173,	'PR',	'PRI',	'Puerto Rico',	'Porto Rico'),
-(174,	'PS',	'PSE',	'Palestine',	'Palestine'),
-(175,	'PT',	'PRT',	'Portugal',	'le Portugal'),
-(176,	'PW',	'PLW',	'Palau',	'Palau'),
-(177,	'PY',	'PRY',	'Paraguay',	'Paraguay'),
-(178,	'QA',	'QAT',	'Qatar',	'Qatar'),
-(179,	'RE',	'REU',	'RÚunion',	'Réunion'),
-(180,	'RO',	'ROM',	'Romania',	'Roumanie'),
-(181,	'RU',	'RUS',	'Russian Federation',	'Fédération Russe'),
-(182,	'RW',	'RWA',	'Rwanda',	'Rwanda'),
-(183,	'SA',	'SAU',	'Saudi Arabia',	'Arabie Saoudite'),
-(184,	'SB',	'SLB',	'Solomon Islands',	'Iles Salomon'),
-(185,	'SC',	'SYC',	'Seychelles',	'Seychelles'),
-(186,	'SD',	'SDN',	'Sudan',	'Soudan'),
-(187,	'SE',	'SWE',	'Sweden',	'Suède'),
-(188,	'SG',	'SGP',	'Singapore',	'Singapour'),
-(189,	'SH',	'SHN',	'Saint Helena',	'Sainte-Hélène'),
-(190,	'SI',	'SVN',	'Slovenia',	'Slovénie'),
-(191,	'SJ',	'SJM',	'Svalbard and Jan Mayen',	'Svalbard et Jan Mayen'),
-(192,	'SK',	'SVK',	'Slovakia',	'Slovaquie'),
-(193,	'SL',	'SLE',	'Sierra Leone',	'Sierra Leone'),
-(194,	'SM',	'SMR',	'San Marino',	'Saint Marin'),
-(195,	'SN',	'SEN',	'Senegal',	'Sénégal'),
-(196,	'SO',	'SOM',	'Somalia',	'Somalie'),
-(197,	'SR',	'SUR',	'Suriname',	'Suriname'),
-(198,	'ST',	'STP',	'Sao Tome and Principe',	'Sao Tomé et Principe'),
-(199,	'SV',	'SLV',	'El Salvador',	'Salvador'),
-(200,	'SY',	'SYR',	'Syria',	'Syrie'),
-(201,	'SZ',	'SWZ',	'Swaziland',	'Swaziland'),
-(202,	'TC',	'TCA',	'Turks and Caicos Islands',	'Iles Turques-et-Caïques'),
-(203,	'TD',	'TCD',	'Chad',	'Tchad'),
-(204,	'TF',	'ATF',	'French Southern territories',	'Territoires du Sud français'),
-(205,	'TG',	'TGO',	'Togo',	'Togo'),
-(206,	'TH',	'THA',	'Thailand',	'Thaïlande'),
-(207,	'TJ',	'TJK',	'Tajikistan',	'Tadjikistan'),
-(208,	'TK',	'TKL',	'Tokelau',	'Tokelau'),
-(209,	'TM',	'TKM',	'Turkmenistan',	'Turkménistan'),
-(210,	'TN',	'TUN',	'Tunisia',	'Tunisie'),
-(211,	'TO',	'TON',	'Tonga',	'Tonga'),
-(212,	'TP',	'TMP',	'East Timor',	'Timor oriental'),
-(213,	'TR',	'TUR',	'Turkey',	'Turquie'),
-(214,	'TT',	'TTO',	'Trinidad and Tobago',	'Trinité-et-Tobago'),
-(215,	'TV',	'TUV',	'Tuvalu',	'Tuvalu'),
-(216,	'TW',	'TWN',	'Taiwan',	'Taïwan'),
-(217,	'TZ',	'TZA',	'Tanzania',	'Tanzanie'),
-(218,	'UA',	'UKR',	'Ukraine',	'Ukraine'),
-(219,	'UG',	'UGA',	'Uganda',	'Ouganda'),
-(220,	'UM',	'UMI',	'United States Minor Outlying Islands',	'Îles mineures éloignées des États-Unis'),
-(221,	'US',	'USA',	'United States',	'États Unis'),
-(222,	'UY',	'URY',	'Uruguay',	'Uruguay'),
-(223,	'UZ',	'UZB',	'Uzbekistan',	'Ouzbékistan'),
-(224,	'VA',	'VAT',	'Holy See (Vatican City State)',	'Saint-Siège (État de la Cité du Vatican)'),
-(225,	'VC',	'VCT',	'Saint Vincent and the Grenadines',	'Saint-Vincent-et-les-Grenadines'),
-(226,	'VE',	'VEN',	'Venezuela',	'Venezuela'),
-(227,	'VG',	'VGB',	'Virgin Islands, British',	'Îles Vierges britanniques'),
-(228,	'VI',	'VIR',	'Virgin Islands, U.S.',	'Îles Vierges américaines, États-Unis'),
-(229,	'VN',	'VNM',	'Vietnam',	'Vietnam'),
-(230,	'VU',	'VUT',	'Vanuatu',	'Vanuatu'),
-(231,	'WF',	'WLF',	'Wallis and Futuna',	'Wallis et Futuna'),
-(232,	'WS',	'WSM',	'Samoa',	'Samoa'),
-(233,	'YE',	'YEM',	'Yemen',	'Yémen'),
-(234,	'YT',	'MYT',	'Mayotte',	'Mayotte'),
-(235,	'YU',	'YUG',	'Yugoslavia',	'Yougoslavie'),
-(236,	'ZA',	'ZAF',	'South Africa',	'Afrique du Sud'),
-(237,	'ZM',	'ZMB',	'Zambia',	'Zambie'),
-(238,	'ZW',	'ZWE',	'Zimbabwe',	'Zimbabwe');
-
-DROP TABLE IF EXISTS `credit`;
-CREATE TABLE `credit` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `ID_user` int(255) NOT NULL,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp(),
-  `count` int(11) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `credit_usage`;
-CREATE TABLE `credit_usage` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `fk_user` int(255) NOT NULL,
-  `fk_media` int(255) NOT NULL,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `ct_center`;
-CREATE TABLE `ct_center` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `fk_organization` int(255) NOT NULL,
-  `fk_probe` int(255) NOT NULL,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `lst_coronary_type`;
-CREATE TABLE `lst_coronary_type` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `code` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-INSERT INTO `lst_coronary_type` (`ID`, `code`) VALUES
-(1,	'{\"fr\":\"Insuffisance coronarienne\", \"en\": \"Coronary insufficiency\"}'),
-(2,	'{\"fr\":\"Athérosclérose\", \"en\": \"Atherosclerosis\"}'),
-(3,	'{\"fr\":\"Infarctus\", \"en\": \"Infarctus\"}');
-
-DROP TABLE IF EXISTS `lst_stroke_type`;
-CREATE TABLE `lst_stroke_type` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `code` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-INSERT INTO `lst_stroke_type` (`ID`, `code`) VALUES
-(1,	'{\"fr\":\"Hémorragie\", \"en\": \"Hemorrhage\"}'),
-(2,	'{\"fr\":\"AIT\", \"en\": \"TIA\"}'),
-(3,	'{\"fr\":\"Infarctus territorial\", \"en\": \"Territorial Infarction\"}'),
-(4,	'{\"fr\":\"Lacunaire\", \"en\": \"Lacunar\"}');
-
-DROP TABLE IF EXISTS `measure`;
-CREATE TABLE `measure` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `type` varchar(64) NOT NULL,
-  `points` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `computation` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `fk_media` int(255) NOT NULL,
-  `frame` tinyint(4) NOT NULL DEFAULT 0,
-  `fk_user` int(255) NOT NULL,
-  `created` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `media`;
-CREATE TABLE `media` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `side` varchar(16) DEFAULT NULL,
-  `location` varchar(16) DEFAULT NULL,
-  `incidence` varchar(32) DEFAULT NULL,
-  `filename` varchar(64) NOT NULL,
-  `metrics` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `fk_visit` int(255) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `organization`;
-CREATE TABLE `organization` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `fk_user` int(255) NOT NULL,
-  `name` varchar(128) NOT NULL,
-  `fk_country` int(255) NOT NULL,
-  `zip` varchar(32) NOT NULL,
-  `city` varchar(128) NOT NULL,
-  `address` text NOT NULL,
-  `phone` varchar(32) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `patient`;
-CREATE TABLE `patient` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `patientID` varchar(128) NOT NULL,
-  `ctPatientID` varchar(128) DEFAULT NULL,
-  `firstname` varchar(128) NOT NULL,
-  `lastname` varchar(128) NOT NULL,
-  `gender` char(1) NOT NULL DEFAULT 'M',
-  `birthDate` date NOT NULL,
-  `height` int(11) DEFAULT NULL,
-  `weight` int(11) DEFAULT NULL,
-  `race` enum('white','african','indian','asian','other') DEFAULT NULL,
-  `fk_birthCountry` int(255) DEFAULT NULL,
-  `fk_residenceCountry` int(255) DEFAULT NULL,
-  `fk_user` int(255) NOT NULL,
-  `created` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `probe`;
-CREATE TABLE `probe` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `fk_user` int(255) NOT NULL,
-  `name` varchar(128) NOT NULL,
-  `brand` varchar(128) NOT NULL,
-  `type` varchar(128) NOT NULL,
-  `year` int(4) DEFAULT NULL,
-  `frequency` float NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `recipient`;
-CREATE TABLE `recipient` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `email` varchar(128) NOT NULL,
-  `fk_user` int(255) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `settings`;
-CREATE TABLE `settings` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `data` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-INSERT INTO `settings` (`ID`, `data`) VALUES
-(1,	'{\"patientListFields\":[{\"name\":\"Sex\",\"display\":0},{\"name\":\"PatientID\",\"display\":1},{\"name\":\"Firstname\",\"display\":1},{\"name\":\"Lastname\",\"display\":0},{\"name\":\"Birthdate\",\"display\":1},{\"name\":\"Height\",\"display\":0},{\"name\":\"Weight\",\"display\":0},{\"name\":\"Last visit\",\"display\":0},{\"name\":\"Visit count\",\"display\":0},{\"name\":\"Image count\",\"display\":0},{\"name\":\"Video count\",\"display\":1}],\"newPatientFields\":[{\"name\":\"Visit date\",\"display\":1,\"required\":0},{\"name\":\"Firstname\",\"display\":1,\"required\":1},{\"name\":\"Lastname\",\"display\":1,\"required\":0},{\"name\":\"Sex\",\"display\":1,\"required\":1},{\"name\":\"Birthdate\",\"display\":1,\"required\":1},{\"name\":\"Height\",\"display\":0,\"required\":0},{\"name\":\"Weight\",\"display\":0,\"required\":0},{\"name\":\"Birth country\",\"display\":1,\"required\":0},{\"name\":\"Residence country\",\"display\":1,\"required\":0}],\"videoDurationMax\":8}');
-
-DROP TABLE IF EXISTS `settings_pacs`;
-CREATE TABLE `settings_pacs` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `data` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `fk_physician` int(255) DEFAULT NULL,
-  `fk_center` int(255) DEFAULT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `user`;
-CREATE TABLE `user` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `activation_token` varchar(127) NOT NULL,
-  `activation_expire` datetime NOT NULL,
-  `activation` datetime DEFAULT NULL,
-  `password` varchar(128) NOT NULL,
-  `firstname` varchar(128) NOT NULL,
-  `lastname` varchar(128) NOT NULL,
-  `email` varchar(128) NOT NULL,
-  `phone` varchar(32) NOT NULL,
-  `type` enum('imt-master','physician','cro','reader','investigator') NOT NULL,
-  `active` tinyint(4) NOT NULL DEFAULT 1,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp(),
-  `fk_center` int(11) DEFAULT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `visit`;
-CREATE TABLE `visit` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `number` varchar(128) NOT NULL,
-  `visitDate` date NOT NULL,
-  `area` varchar(16) DEFAULT NULL,
-  `markers` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL DEFAULT '[]',
-  `completed` datetime DEFAULT NULL,
-  `fk_patient` int(255) NOT NULL,
-  `fk_reader` int(255) DEFAULT NULL,
-  `created` datetime NOT NULL DEFAULT current_timestamp(),
-  PRIMARY KEY (`ID`)
-) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-
-
-
-
-
-
-CREATE DATABASE `iimt_mathcloud_shadow` /*!40100 DEFAULT CHARACTER SET utf8 */;
-USE `iimt_mathcloud_shadow`;
-
-DROP TABLE IF EXISTS `media`;
-CREATE TABLE `media` (
-  `ID` int(255) NOT NULL AUTO_INCREMENT,
-  `side` varchar(16) NOT NULL,
-  `location` varchar(16) NOT NULL,
-  `incidence` varchar(32) NOT NULL,
-  `filename` varchar(64) NOT NULL,
-  `metrics` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `fk_visit` int(255) NOT NULL,
-  PRIMARY KEY (`ID`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-
-
-
-
-
-CREATE DATABASE IF NOT EXISTS `iimt_mathcloud_audit` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
-USE `iimt_mathcloud_audit`;
-
--- --------------------------------------------------------
-
---
--- Table structure for table `activity`
---
-
-DROP TABLE IF EXISTS `activity`;
-CREATE TABLE `activity` (
-  `ID` int(255) NOT NULL,
-  `ID_ray` int(255) NOT NULL,
-  `data` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp()
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
--- --------------------------------------------------------
-
---
--- Table structure for table `ray`
---
-
-DROP TABLE IF EXISTS `ray`;
-CREATE TABLE `ray` (
-  `ID` int(255) NOT NULL,
-  `userAgent` text NOT NULL,
-  `apiKey` varchar(128) NOT NULL,
-  `ipData` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `locationData` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `userData` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
-  `stamp` datetime NOT NULL DEFAULT current_timestamp()
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
---
--- Indexes for dumped tables
---
-
---
--- Indexes for table `activity`
---
-ALTER TABLE `activity`
-  ADD PRIMARY KEY (`ID`);
-
---
--- Indexes for table `ray`
---
-ALTER TABLE `ray`
-  ADD PRIMARY KEY (`ID`);
-
---
--- AUTO_INCREMENT for dumped tables
---
-
---
--- AUTO_INCREMENT for table `activity`
---
-ALTER TABLE `activity`
-  MODIFY `ID` int(255) NOT NULL AUTO_INCREMENT;
-
---
--- AUTO_INCREMENT for table `ray`
---
-ALTER TABLE `ray`
-  MODIFY `ID` int(255) NOT NULL AUTO_INCREMENT;
-COMMIT;
-

debian/Math-Cloud-server/etc/apache2/sites-available/api.conf

@@ -1,146 +0,0 @@
-<IfModule mod_ssl.c>
-	<VirtualHost _default_:443>
-		ServerAdmin webmaster@localhost
-		ServerName api.ipsocloud.com
-
-		DocumentRoot /var/www/api
-
-		# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
-		# error, crit, alert, emerg.
-		# It is also possible to configure the loglevel for particular
-		# modules, e.g.
-		#LogLevel info ssl:warn
-
-		ErrorLog ${APACHE_LOG_DIR}/error.log
-		CustomLog ${APACHE_LOG_DIR}/access.log combined
-
-		# For most configuration files from conf-available/, which are
-		# enabled or disabled at a global level, it is possible to
-		# include a line for only one particular virtual host. For example the
-		# following line enables the CGI configuration for this host only
-		# after it has been globally disabled with "a2disconf".
-		#Include conf-available/serve-cgi-bin.conf
-
-		#   SSL Engine Switch:
-		#   Enable/Disable SSL for this virtual host.
-		SSLEngine on
-
-		#   A self-signed (snakeoil) certificate can be created by installing
-		#   the ssl-cert package. See
-		#   /usr/share/doc/apache2/README.Debian.gz for more info.
-		#   If both key and certificate are stored in the same file, only the
-		#   SSLCertificateFile directive is needed.
-		#SSLCertificateFile	/etc/ssl/certs/apache-selfsigned.crt
-		#SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
-		#SSLCACertificateFile	/etc/ssl/ipsocloud.ca
-
-		#   Server Certificate Chain:
-		#   Point SSLCertificateChainFile at a file containing the
-		#   concatenation of PEM encoded CA certificates which form the
-		#   certificate chain for the server certificate. Alternatively
-		#   the referenced file can be the same as SSLCertificateFile
-		#   when the CA certificates are directly appended to the server
-		#   certificate for convinience.
-		#SSLCertificateChainFile /etc/apache2/ssl.crt/server-ca.crt
-
-		#   Certificate Authority (CA):
-		#   Set the CA certificate verification path where to find CA
-		#   certificates for client authentication or alternatively one
-		#   huge file containing all of them (file must be PEM encoded)
-		#   Note: Inside SSLCACertificatePath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCACertificatePath /etc/ssl/certs/
-		#SSLCACertificateFile /etc/apache2/ssl.crt/ca-bundle.crt
-
-		#   Certificate Revocation Lists (CRL):
-		#   Set the CA revocation path where to find CA CRLs for client
-		#   authentication or alternatively one huge file containing all
-		#   of them (file must be PEM encoded)
-		#   Note: Inside SSLCARevocationPath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCARevocationPath /etc/apache2/ssl.crl/
-		#SSLCARevocationFile /etc/apache2/ssl.crl/ca-bundle.crl
-
-		#   Client Authentication (Type):
-		#   Client certificate verification type and depth.  Types are
-		#   none, optional, require and optional_no_ca.  Depth is a
-		#   number which specifies how deeply to verify the certificate
-		#   issuer chain before deciding the certificate is not valid.
-		#SSLVerifyClient require
-		#SSLVerifyDepth  10
-
-		#   SSL Engine Options:
-		#   Set various options for the SSL engine.
-		#   o FakeBasicAuth:
-		#	 Translate the client X.509 into a Basic Authorisation.  This means that
-		#	 the standard Auth/DBMAuth methods can be used for access control.  The
-		#	 user name is the `one line' version of the client's X.509 certificate.
-		#	 Note that no password is obtained from the user. Every entry in the user
-		#	 file needs this password: `xxj31ZMTZzkVA'.
-		#   o ExportCertData:
-		#	 This exports two additional environment variables: SSL_CLIENT_CERT and
-		#	 SSL_SERVER_CERT. These contain the PEM-encoded certificates of the
-		#	 server (always existing) and the client (only existing when client
-		#	 authentication is used). This can be used to import the certificates
-		#	 into CGI scripts.
-		#   o StdEnvVars:
-		#	 This exports the standard SSL/TLS related `SSL_*' environment variables.
-		#	 Per default this exportation is switched off for performance reasons,
-		#	 because the extraction step is an expensive operation and is usually
-		#	 useless for serving static content. So one usually enables the
-		#	 exportation for CGI and SSI requests only.
-		#   o OptRenegotiate:
-		#	 This enables optimized SSL connection renegotiation handling when SSL
-		#	 directives are used in per-directory context.
-		#SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
-		<FilesMatch "\.(cgi|shtml|phtml|php)$">
-				SSLOptions +StdEnvVars
-		</FilesMatch>
-		<Directory /usr/lib/cgi-bin>
-				SSLOptions +StdEnvVars
-		</Directory>
-		<Directory /var/www/api/>
-		    Options Indexes FollowSymLinks
-		    AllowOverride All
-		    SSLOptions +StdEnvVars
-		    Require all granted
-			Header set Access-Control-Allow-Origin "*"
-		</Directory>
-
-		#   SSL Protocol Adjustments:
-		#   The safe and default but still SSL/TLS standard compliant shutdown
-		#   approach is that mod_ssl sends the close notify alert but doesn't wait for
-		#   the close notify alert from client. When you need a different shutdown
-		#   approach you can use one of the following variables:
-		#   o ssl-unclean-shutdown:
-		#	 This forces an unclean shutdown when the connection is closed, i.e. no
-		#	 SSL close notify alert is send or allowed to received.  This violates
-		#	 the SSL/TLS standard but is needed for some brain-dead browsers. Use
-		#	 this when you receive I/O errors because of the standard approach where
-		#	 mod_ssl sends the close notify alert.
-		#   o ssl-accurate-shutdown:
-		#	 This forces an accurate shutdown when the connection is closed, i.e. a
-		#	 SSL close notify alert is send and mod_ssl waits for the close notify
-		#	 alert of the client. This is 100% SSL/TLS standard compliant, but in
-		#	 practice often causes hanging connections with brain-dead browsers. Use
-		#	 this only for browsers where you know that their SSL implementation
-		#	 works correctly.
-		#   Notice: Most problems of broken clients are also related to the HTTP
-		#   keep-alive facility, so you usually additionally want to disable
-		#   keep-alive for those clients, too. Use variable "nokeepalive" for this.
-		#   Similarly, one has to force some clients to use HTTP/1.0 to workaround
-		#   their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and
-		#   "force-response-1.0" for this.
-		# BrowserMatch "MSIE [2-6]" \
-		#		nokeepalive ssl-unclean-shutdown \
-		#		downgrade-1.0 force-response-1.0
-
-		SSLCertificateFile	/etc/letsencrypt/live/api.ipsocloud.com/fullchain.pem
-		SSLCertificateKeyFile	/etc/letsencrypt/live/api.ipsocloud.com/privkey.pem
-Include /etc/letsencrypt/options-ssl-apache.conf
-	</VirtualHost>
-</IfModule>
-
-# vim: syntax=apache ts=4 sw=4 sts=4 sr noet

debian/Math-Cloud-server/etc/apache2/sites-available/cro.conf

@@ -1,139 +0,0 @@
-<IfModule mod_ssl.c>
-	<VirtualHost _default_:443>
-		ServerAdmin webmaster@localhost
-		ServerName cro.ipsocloud.com
-
-		DocumentRoot /var/www/cro
-
-		# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
-		# error, crit, alert, emerg.
-		# It is also possible to configure the loglevel for particular
-		# modules, e.g.
-		#LogLevel info ssl:warn
-
-		ErrorLog ${APACHE_LOG_DIR}/error.log
-		CustomLog ${APACHE_LOG_DIR}/access.log combined
-
-		# For most configuration files from conf-available/, which are
-		# enabled or disabled at a global level, it is possible to
-		# include a line for only one particular virtual host. For example the
-		# following line enables the CGI configuration for this host only
-		# after it has been globally disabled with "a2disconf".
-		#Include conf-available/serve-cgi-bin.conf
-
-		#   SSL Engine Switch:
-		#   Enable/Disable SSL for this virtual host.
-		SSLEngine on
-
-		#   A self-signed (snakeoil) certificate can be created by installing
-		#   the ssl-cert package. See
-		#   /usr/share/doc/apache2/README.Debian.gz for more info.
-		#   If both key and certificate are stored in the same file, only the
-		#   SSLCertificateFile directive is needed.
-		#SSLCertificateFile	/etc/ssl/certs/apache-selfsigned.crt
-		#SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
-		SSLCACertificateFile	/etc/ssl/ipsocloud.ca
-
-		#   Server Certificate Chain:
-		#   Point SSLCertificateChainFile at a file containing the
-		#   concatenation of PEM encoded CA certificates which form the
-		#   certificate chain for the server certificate. Alternatively
-		#   the referenced file can be the same as SSLCertificateFile
-		#   when the CA certificates are directly appended to the server
-		#   certificate for convinience.
-		#SSLCertificateChainFile /etc/apache2/ssl.crt/server-ca.crt
-
-		#   Certificate Authority (CA):
-		#   Set the CA certificate verification path where to find CA
-		#   certificates for client authentication or alternatively one
-		#   huge file containing all of them (file must be PEM encoded)
-		#   Note: Inside SSLCACertificatePath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCACertificatePath /etc/ssl/certs/
-		#SSLCACertificateFile /etc/apache2/ssl.crt/ca-bundle.crt
-
-		#   Certificate Revocation Lists (CRL):
-		#   Set the CA revocation path where to find CA CRLs for client
-		#   authentication or alternatively one huge file containing all
-		#   of them (file must be PEM encoded)
-		#   Note: Inside SSLCARevocationPath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCARevocationPath /etc/apache2/ssl.crl/
-		#SSLCARevocationFile /etc/apache2/ssl.crl/ca-bundle.crl
-
-		#   Client Authentication (Type):
-		#   Client certificate verification type and depth.  Types are
-		#   none, optional, require and optional_no_ca.  Depth is a
-		#   number which specifies how deeply to verify the certificate
-		#   issuer chain before deciding the certificate is not valid.
-		#SSLVerifyClient require
-		#SSLVerifyDepth  10
-
-		#   SSL Engine Options:
-		#   Set various options for the SSL engine.
-		#   o FakeBasicAuth:
-		#	 Translate the client X.509 into a Basic Authorisation.  This means that
-		#	 the standard Auth/DBMAuth methods can be used for access control.  The
-		#	 user name is the `one line' version of the client's X.509 certificate.
-		#	 Note that no password is obtained from the user. Every entry in the user
-		#	 file needs this password: `xxj31ZMTZzkVA'.
-		#   o ExportCertData:
-		#	 This exports two additional environment variables: SSL_CLIENT_CERT and
-		#	 SSL_SERVER_CERT. These contain the PEM-encoded certificates of the
-		#	 server (always existing) and the client (only existing when client
-		#	 authentication is used). This can be used to import the certificates
-		#	 into CGI scripts.
-		#   o StdEnvVars:
-		#	 This exports the standard SSL/TLS related `SSL_*' environment variables.
-		#	 Per default this exportation is switched off for performance reasons,
-		#	 because the extraction step is an expensive operation and is usually
-		#	 useless for serving static content. So one usually enables the
-		#	 exportation for CGI and SSI requests only.
-		#   o OptRenegotiate:
-		#	 This enables optimized SSL connection renegotiation handling when SSL
-		#	 directives are used in per-directory context.
-		#SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
-		<FilesMatch "\.(cgi|shtml|phtml|php)$">
-				SSLOptions +StdEnvVars
-		</FilesMatch>
-		<Directory /usr/lib/cgi-bin>
-				SSLOptions +StdEnvVars
-		</Directory>
-
-		#   SSL Protocol Adjustments:
-		#   The safe and default but still SSL/TLS standard compliant shutdown
-		#   approach is that mod_ssl sends the close notify alert but doesn't wait for
-		#   the close notify alert from client. When you need a different shutdown
-		#   approach you can use one of the following variables:
-		#   o ssl-unclean-shutdown:
-		#	 This forces an unclean shutdown when the connection is closed, i.e. no
-		#	 SSL close notify alert is send or allowed to received.  This violates
-		#	 the SSL/TLS standard but is needed for some brain-dead browsers. Use
-		#	 this when you receive I/O errors because of the standard approach where
-		#	 mod_ssl sends the close notify alert.
-		#   o ssl-accurate-shutdown:
-		#	 This forces an accurate shutdown when the connection is closed, i.e. a
-		#	 SSL close notify alert is send and mod_ssl waits for the close notify
-		#	 alert of the client. This is 100% SSL/TLS standard compliant, but in
-		#	 practice often causes hanging connections with brain-dead browsers. Use
-		#	 this only for browsers where you know that their SSL implementation
-		#	 works correctly.
-		#   Notice: Most problems of broken clients are also related to the HTTP
-		#   keep-alive facility, so you usually additionally want to disable
-		#   keep-alive for those clients, too. Use variable "nokeepalive" for this.
-		#   Similarly, one has to force some clients to use HTTP/1.0 to workaround
-		#   their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and
-		#   "force-response-1.0" for this.
-		# BrowserMatch "MSIE [2-6]" \
-		#		nokeepalive ssl-unclean-shutdown \
-		#		downgrade-1.0 force-response-1.0
-
-		SSLCertificateFile	/etc/letsencrypt/live/cro.ipsocloud.com/fullchain.pem
-		SSLCertificateKeyFile	/etc/letsencrypt/live/cro.ipsocloud.com/privkey.pem
-Include /etc/letsencrypt/options-ssl-apache.conf
-	</VirtualHost>
-</IfModule>
-
-# vim: syntax=apache ts=4 sw=4 sts=4 sr noet

debian/Math-Cloud-server/etc/apache2/sites-available/www.conf

@@ -1,152 +0,0 @@
-<VirtualHost *:80>
-        ServerName www.ipsocloud.com
-        DocumentRoot /var/www/www/
-        <Directory /var/www/www>
-                AllowOverride All
-                Options Indexes FollowSymLinks
-                Require all granted
-        </Directory>
-        RewriteEngine On
-        RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
-</VirtualHost>
-
-
-<IfModule mod_ssl.c>
-	<VirtualHost _default_:443>
-		ServerAdmin webmaster@localhost
-		ServerName www.ipsocloud.com
-
-		DocumentRoot /var/www/www
-
-		# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
-		# error, crit, alert, emerg.
-		# It is also possible to configure the loglevel for particular
-		# modules, e.g.
-		#LogLevel info ssl:warn
-
-		ErrorLog ${APACHE_LOG_DIR}/error.log
-		CustomLog ${APACHE_LOG_DIR}/access.log combined
-
-		# For most configuration files from conf-available/, which are
-		# enabled or disabled at a global level, it is possible to
-		# include a line for only one particular virtual host. For example the
-		# following line enables the CGI configuration for this host only
-		# after it has been globally disabled with "a2disconf".
-		#Include conf-available/serve-cgi-bin.conf
-
-		#   SSL Engine Switch:
-		#   Enable/Disable SSL for this virtual host.
-		SSLEngine on
-
-		#   A self-signed (snakeoil) certificate can be created by installing
-		#   the ssl-cert package. See
-		#   /usr/share/doc/apache2/README.Debian.gz for more info.
-		#   If both key and certificate are stored in the same file, only the
-		#   SSLCertificateFile directive is needed.
-		#SSLCertificateFile	/etc/ssl/certs/apache-selfsigned.crt
-		#SSLCertificateKeyFile /etc/ssl/private/apache-selfsigned.key
-		#SSLCACertificateFile	/etc/ssl/ipsocloud.ca
-
-		#   Server Certificate Chain:
-		#   Point SSLCertificateChainFile at a file containing the
-		#   concatenation of PEM encoded CA certificates which form the
-		#   certificate chain for the server certificate. Alternatively
-		#   the referenced file can be the same as SSLCertificateFile
-		#   when the CA certificates are directly appended to the server
-		#   certificate for convinience.
-		#SSLCertificateChainFile /etc/apache2/ssl.crt/server-ca.crt
-
-		#   Certificate Authority (CA):
-		#   Set the CA certificate verification path where to find CA
-		#   certificates for client authentication or alternatively one
-		#   huge file containing all of them (file must be PEM encoded)
-		#   Note: Inside SSLCACertificatePath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCACertificatePath /etc/ssl/certs/
-		#SSLCACertificateFile /etc/apache2/ssl.crt/ca-bundle.crt
-
-		#   Certificate Revocation Lists (CRL):
-		#   Set the CA revocation path where to find CA CRLs for client
-		#   authentication or alternatively one huge file containing all
-		#   of them (file must be PEM encoded)
-		#   Note: Inside SSLCARevocationPath you need hash symlinks
-		#		 to point to the certificate files. Use the provided
-		#		 Makefile to update the hash symlinks after changes.
-		#SSLCARevocationPath /etc/apache2/ssl.crl/
-		#SSLCARevocationFile /etc/apache2/ssl.crl/ca-bundle.crl
-
-		#   Client Authentication (Type):
-		#   Client certificate verification type and depth.  Types are
-		#   none, optional, require and optional_no_ca.  Depth is a
-		#   number which specifies how deeply to verify the certificate
-		#   issuer chain before deciding the certificate is not valid.
-		#SSLVerifyClient require
-		#SSLVerifyDepth  10
-
-		#   SSL Engine Options:
-		#   Set various options for the SSL engine.
-		#   o FakeBasicAuth:
-		#	 Translate the client X.509 into a Basic Authorisation.  This means that
-		#	 the standard Auth/DBMAuth methods can be used for access control.  The
-		#	 user name is the `one line' version of the client's X.509 certificate.
-		#	 Note that no password is obtained from the user. Every entry in the user
-		#	 file needs this password: `xxj31ZMTZzkVA'.
-		#   o ExportCertData:
-		#	 This exports two additional environment variables: SSL_CLIENT_CERT and
-		#	 SSL_SERVER_CERT. These contain the PEM-encoded certificates of the
-		#	 server (always existing) and the client (only existing when client
-		#	 authentication is used). This can be used to import the certificates
-		#	 into CGI scripts.
-		#   o StdEnvVars:
-		#	 This exports the standard SSL/TLS related `SSL_*' environment variables.
-		#	 Per default this exportation is switched off for performance reasons,
-		#	 because the extraction step is an expensive operation and is usually
-		#	 useless for serving static content. So one usually enables the
-		#	 exportation for CGI and SSI requests only.
-		#   o OptRenegotiate:
-		#	 This enables optimized SSL connection renegotiation handling when SSL
-		#	 directives are used in per-directory context.
-		#SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
-		<FilesMatch "\.(cgi|shtml|phtml|php)$">
-				SSLOptions +StdEnvVars
-		</FilesMatch>
-		<Directory /usr/lib/cgi-bin>
-				SSLOptions +StdEnvVars
-		</Directory>
-
-		#   SSL Protocol Adjustments:
-		#   The safe and default but still SSL/TLS standard compliant shutdown
-		#   approach is that mod_ssl sends the close notify alert but doesn't wait for
-		#   the close notify alert from client. When you need a different shutdown
-		#   approach you can use one of the following variables:
-		#   o ssl-unclean-shutdown:
-		#	 This forces an unclean shutdown when the connection is closed, i.e. no
-		#	 SSL close notify alert is send or allowed to received.  This violates
-		#	 the SSL/TLS standard but is needed for some brain-dead browsers. Use
-		#	 this when you receive I/O errors because of the standard approach where
-		#	 mod_ssl sends the close notify alert.
-		#   o ssl-accurate-shutdown:
-		#	 This forces an accurate shutdown when the connection is closed, i.e. a
-		#	 SSL close notify alert is send and mod_ssl waits for the close notify
-		#	 alert of the client. This is 100% SSL/TLS standard compliant, but in
-		#	 practice often causes hanging connections with brain-dead browsers. Use
-		#	 this only for browsers where you know that their SSL implementation
-		#	 works correctly.
-		#   Notice: Most problems of broken clients are also related to the HTTP
-		#   keep-alive facility, so you usually additionally want to disable
-		#   keep-alive for those clients, too. Use variable "nokeepalive" for this.
-		#   Similarly, one has to force some clients to use HTTP/1.0 to workaround
-		#   their broken HTTP/1.1 implementation. Use variables "downgrade-1.0" and
-		#   "force-response-1.0" for this.
-		# BrowserMatch "MSIE [2-6]" \
-		#		nokeepalive ssl-unclean-shutdown \
-		#		downgrade-1.0 force-response-1.0
-
-		SSLCertificateFile	/etc/letsencrypt/live/www.ipsocloud.com/fullchain.pem
-		SSLCertificateKeyFile	/etc/letsencrypt/live/www.ipsocloud.com/privkey.pem
-Include /etc/letsencrypt/options-ssl-apache.conf
-	</VirtualHost>
-</IfModule>
-
-# vim: syntax=apache ts=4 sw=4 sts=4 sr noet