MAth-Cloud-3.0.0/api.ipsocloud.com/math-plaque/imt/PlaqueBase.h

////////////////////////////
// Fichier PlaqueBase.h   //
////////////////////////////
#pragma once

/*------------------------------------------------\
                 Includes
\-------------------------------------------------*/

#include "scale.h"
#include "vector.h"
#include "CPlaqueInfo.h"
#include "CPlaqueResult.h"
#include "region.h"
#include "img.h"

#include <vector>
#include <cassert>

#include <QList>

class QImage;

/*----------------------------------------------------------\
                        Constantes
\----------------------------------------------------------*/

const short NBVECTEURSMAX = 8184;
const short NBPTSLONGEANTMAX = 512;

#ifndef max
#define max(a,b)            (((a) > (b)) ? (a) : (b))
#endif

#ifndef min
#define min(a,b)            (((a) < (b)) ? (a) : (b))
#endif

/*----------------------------------------------------------\
                       Classes
\----------------------------------------------------------*/
class CPlaqueResult;

enum EnumEtape
{
  etapeRien,
  etapeSegments,
  etapeTacheSeuil,
  etapeReglage
};

enum enumType
{
	typeUndefined,
	typeBW,
	typeRGB,
	typeManual
};

class CPlaqueBase
{
  public:
  CPlaqueBase();
  virtual  ~CPlaqueBase();

  CPlaqueInfo *m_pMeasures;  // pointeur sur mesures de Plaque

  void RAZ();
  void Release();

  unsigned long m_clrVert;
  unsigned long m_clrOrange;
  unsigned long m_clrBleue;

  enumType m_type;

  int m_nSommeLongueurs;
	int m_nMesures;
  int m_nMesuresTotal;
  int m_nLongueurMax;
	
  EnumEtape m_Etape;

  int m_iTache;
  int m_nPointsDansPlaque;
  int m_iSommeIntensitesPlaque;
  int m_IntervallesIntensite[3];   // Les 3 intervalles d'intensité
  int m_iMax;

  img m_wimg;  // Image de travail pour mettre les pixels verts
	
  Point m_tPtLongeantPlaque[NBPTSLONGEANTMAX + NBVECTEURSMAX];
  int m_nPtLongeantPlaque;

  // Extrémités des vecteurs trouvées
//	std::vector< Point > m_ptList; // pour la spline
//  short	m_nPtList;

Point	m_tbPtsTrouvesFin[NBVECTEURSMAX];
  short	m_nVecteursTrouves;

  // Centre de la tache indiquant le seuil inférieur
  Point	m_ptInferieur;

  // (0=aiguilles, 1=inverse) calculé d'après position du pt inférieur et du 1° segment utilisateur
  int m_nSensTrigo;
  int m_nNetBTraite;

  // Les 2 points limites extérieures du seuillage par propagation
  Point m_pointLimite1;
  Point m_pointLimite2;	

	Region m_rgnATraiter;              // région de traitement
	Rect m_rcStenose;                  // rectangle englobant de la sténose

  int m_debug1; // Variables pour Debugger la partie Alchemy 
  int m_debug2; 
  int m_debug3; 
  int m_debug4; 
  int m_debug5; 

  // Variables pour l'analyse des plaques 
 	double m_scoreRepartition;	// Score de répartition

	double m_scoreRepartitionR;	// Dans le rouge
	double m_scoreRepartitionB;	// Dans le jaune
	double m_scoreRepartitionV;	// Dans le vert

	double m_surfaceR;			// Surface Rouge 
	double m_surfaceB;
	double m_surfaceV;

	double m_surface;			// totale

	int m_nbPixelsR;			// Nombre de pixels rouges 
	int m_nbPixelsB;
	int m_nbPixelsV;

	int m_nbPixels;				// Total 

	int m_GSM;					//  Grey Scale Median
  
  protected:
    QImage *m_result;
    //ExtendedImage m_result2;
    unsigned long *m_etudie;
	
  unsigned int m_uErrorID;  // ID de la chaîne à afficher en cas d'erreur

	int Mesurer_3(int nSeuil);
    int ParametrerRegionATraiter();

  protected:
    bool SetRegion (const CVector &vFirst, const CVector &vLast, int iLength);

  protected:	
    //***** Mesurer 1 des segments définis / utilisateur
   int Mesurer_3_1Segment (const Point &pt1, const Point &pt2);
    void CalculerSensVecteurs ();
    
    //***** Seuillage par propagation
    virtual int TraiterPoint(int x, int y);
    int Threshold(int iMax);

    // Suivit de contour de plaque
    bool SuiviContour();
    bool IsBorder(int x, int y);
    bool SuiviContourLocal(int x, int y, double Xd, double Yd, bool Initialise = false);	
    void SuiviContourRemplis(int x, int y);

    //***** Calcul de la surface & de l'intensité de la plaque
    int CalculerSurfaceEtIntensitePlaque(bool bManuelle);

  public:
    int CalculerPlaqueManuelle();

    bool DoBlobColoring();
    bool DoClosing();
    double Get_SommeLongueurs(); // [LAU - 2/5/2006]

	// Returns the last error generated.  
  // Use CString.LoadString() to get the corresponding text
  unsigned int GetErrorID(void);
	virtual bool PointInBufferResult(const int& x, const int &y);
  virtual bool PointInBufferResult(const Point& pt);
	virtual int GetIntensityResult(const int& x, const int& y);
	virtual int GetIntensityResult(const Point& pt);
	virtual bool IsColor(int x, int y);
	virtual unsigned long GetPixelResult(const int& x, const int& y);
	virtual unsigned long GetPixelResult(const Point& pt);
	virtual unsigned long GetPixelEtudie(const int& x, const int& y);
	virtual unsigned long GetPixelEtudie(const Point& pt);
//	virtual void SetPixelResult(Point& pt);
	virtual void SetPixelResult(int x, int y);
	virtual void SetPixelEtudie(Point& pt, unsigned long vColor);
	virtual void SetPixelEtudie(int x, int y, unsigned long vColor);
	virtual int GetWidth();
	virtual int GetHeight();
	virtual void CopyResultDansEtudie();
    //virtual void AffectLeadResult();
    //virtual void CopieResultSvg();

	virtual void GraphMeanInit() { };
	virtual void GraphMeanAddMeasure( bool, double ) { };

    int OnLButtonUp(QImage *h_image, int x, int y);
	virtual int OnLButtonUp(int x, int y);
	virtual int OnLButtonUp(Point& point);
	virtual unsigned char GetIntensityTache(Point& ptCentre, int nRayonTache);
	
    virtual int calculPlaque(QImage *h_image, int x, int y, int nbPts, const QList<Point>& pts/*, int seuil1, int seuil2*/);
    //virtual int TestFantome(QImage *h_image, CPlaqueResult * );
    virtual int calculPlaque2(QImage *h_image, int nbPts, unsigned char *points);
  virtual void AnalysePlaque(int seuil1, int seuil2);
//  virtual void CalculScoreRepartition();

	double Mean();
	double Max();
	unsigned char Density(); 
	double Surface();
	bool TestCouleur();
};