MAth-Cloud-3.0.0/www.ipsocloud.com/intimamedia.com/cpp/libIMTDebian/libs/MeasurePlaque/Plaque/plaqueinterface.cpp

#include "PlaqueInterface.h"
#include "PlaqueBase.h"
#include "scale.h"

#include "../Container/extendedimage.h"
#include "../Container/Video.h"
#include "../IO/DicomIO.h"
#include "../Mouchard/Mouchard.h"

#include <cmath>

const CScale *g_pCurrentScale;

#define SQR( x )  (( x ) * ( x ))

PlaqueInterface::PlaqueInterface():Singleton< PlaqueInterface >()
{
}

bool PlaqueInterface::initialize( std::string fileName, double pixelSizeX, double pixelSizeY )
{
  bool status = false;

  if ( Mouchard::getInstance().IsDLLValid() )
  {
    m_image.Destroy();

    double m_pixelSizeX = pixelSizeX;
    double m_pixelSizeY = pixelSizeY;
/*
    if ( DicomIO::getInstance().read( fileName, m_image ) )
    {
      if ( ( pixelSizeX < 0.0 ) && ( pixelSizeY < 0.0 ) )
      {
        m_pixelSizeX = m_image.GetResolutionX();
        m_pixelSizeY = m_image.GetResolutionY();
      }

      status = true;
    }
    else
    {
      status = false;
    }
*/
    if ( status && ( m_pixelSizeX > 0.0 ) && ( m_pixelSizeY > 0.0 ) )
    {
      double pixelSize = m_pixelSizeX < m_pixelSizeY ? m_pixelSizeX : m_pixelSizeY;
      g_pCurrentScale = new CScale("DLL scale", pixelSize, pixelSize);
    }
  }

  return status;
}

bool PlaqueInterface::initialize( const char* buffer, int width, int height, int bpp, bool upsideDown, double pixelSizeX, double pixelSizeY )
{
  if ( Mouchard::getInstance().IsDLLValid() && buffer &&
       ( pixelSizeX > 0.0 ) && ( pixelSizeY > 0.0 ) &&
       ( ( bpp == 8 ) || ( bpp == 24 ) || ( bpp == 32 ) ) )
  {
    bool padding = false;
    const unsigned long destWidth = 3 * width;
    const long nextRow = upsideDown ? -2 * width * bpp / 8 : 0;
    register const char* p = buffer + ( upsideDown ? ( height - 1 ) * width * bpp / 8 : 0 );
    const int gap = padding ? ( 4 - destWidth & 0x3 ) & 0x3 : 0;
    //const unsigned long count = ( destWidth + gap ) * height;

    m_image.Destroy();

    if ( m_image.Create( width, height, 24 ) )
    {
      if ( bpp == 8 )
      {
        register char* q = (char*)m_image.GetBits();
        register int x;
        register int y;
        register char value;

        for ( y = height; y--; p += nextRow, q += gap )
        {
          x = width;

          while ( x-- )
          {
            value = *p++;
            *q++ = value;
            *q++ = value;
            *q++ = value;
          }
        }
      }
      else if ( bpp == 24 )
      {
        register char* q = (char*)m_image.GetBits();
        register int x;
        register int y;

        for ( y = height; y--; p += nextRow, q += gap )
        {
          x = destWidth;

          while ( x-- )
          {
            *q++ = *p++;
          }
        }
      }
      else if ( bpp == 32 )
      {
        register char* q = (char*)m_image.GetBits();
        register int x;
        register int y;

        for ( y = height; y--; p += nextRow, q += gap )
        {
          x = width;

          while ( x-- )
          {
// Pour Version Alchemy Flex : 
/*
            *q++ = *( p + 1 );
            *q++ = *( p + 2 );
            *q++ = *( p + 3 );
            p += 4;
*/  		  		  
			*q++ = *( p + 0 );
            *q++ = *( p + 1 );
            *q++ = *( p + 2 );
            p += 4;
          }
        }
      }

      double pixelSize = ( pixelSizeX < pixelSizeY ) ? pixelSizeX : pixelSizeY;
      g_pCurrentScale = new CScale("DLL scale", pixelSize, pixelSize);

      return true;
    }
  }

  return false;
}


int PlaqueInterface::computePlaque( int x, int y, int nbPts, unsigned char *points, CPlaqueResult* result, int seuil1, int seuil2 )
{
  int retour;
  int i; 
 
  retour =2; 

  if ( !m_image.IsNull() && result )
  {
    retour = 12;

    CPlaqueBase cplaque;

    retour = cplaque.calculPlaque(&m_image, x, y, nbPts, points, seuil1, seuil2);

     retour = 3;
   //  Remplissage des valeurs dans result
    result->result->code_retour = retour;
    
    result->result->code_debug1 = cplaque.m_debug1;
    result->result->code_debug2 = cplaque.m_debug2;
    result->result->code_debug3 = cplaque.m_debug3;
    result->result->code_debug4 = cplaque.m_debug4;
    result->result->code_debug5 = cplaque.m_debug5;
     
    result->result->m_type = cplaque.m_type; 
    result->result->m_Etape = cplaque.m_Etape;
    
    result->result->plaque_max_thickness = cplaque.Max();
    result->result->plaque_mean_thickness = cplaque.Mean();
    result->result->plaque_area = cplaque.Surface();
    result->result->plaque_mean_density = cplaque.Density();
     
    result->result->numberOfMeasures = cplaque.m_nMesures;
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
//    result->result->m_nPtList = cplaque.m_nPtList;

    result->result->m_ptInferieur.x = cplaque.m_ptInferieur.x;
    result->result->m_ptInferieur.y = cplaque.m_ptInferieur.y;
//    result->result->m_dataImg = cplaque.m_wimg.data;

  // Transfert de l'image résultats de l'analyse 
    unsigned char *dadd, *dadd2, *amax;
    result->result->m_nbpix = cplaque.m_wimg.nbpix;
    
	result->result->m_dataImg = new unsigned char[cplaque.m_wimg.nbpix];
    dadd = (unsigned char *) cplaque.m_wimg.data;
    amax = dadd + cplaque.m_wimg.nbpix;
    dadd2 =  result->result->m_dataImg;
    while (dadd < amax)
    {
      *dadd2 = *dadd;
      dadd++;
      dadd2++;      
    }   
    
	if ( result->result->m_tPtLongeantPlaque )
    {
      delete[] result->result->m_tPtLongeantPlaque;
    }
     
	result->result->m_tPtLongeantPlaque = new plaque::Point[ cplaque.m_nPtLongeantPlaque ];
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
 
	for ( i = 0; i < cplaque.m_nPtLongeantPlaque; i++ )
    {
      result->result->m_tPtLongeantPlaque[ i ].x = cplaque.m_tPtLongeantPlaque[ i ].x;
      result->result->m_tPtLongeantPlaque[ i ].y = cplaque.m_tPtLongeantPlaque[ i ].y;
    }
 
 	if ( result->result->m_tbPtsTrouvesFin )
    {
      delete[] result->result->m_tbPtsTrouvesFin;
    }
     
	result->result->m_tbPtsTrouvesFin = new plaque::Point[ cplaque.m_nVecteursTrouves ];
    result->result->m_nVecteursTrouves = cplaque.m_nVecteursTrouves;
 
	for ( i = 0; i < cplaque.m_nVecteursTrouves; i++ )
    {
      result->result->m_tbPtsTrouvesFin[ i ].x = cplaque.m_tbPtsTrouvesFin[ i ].x;
      result->result->m_tbPtsTrouvesFin[ i ].y = cplaque.m_tbPtsTrouvesFin[ i ].y;
    }
 
//  Point	*m_ptList;

    return retour;
  }
  else
  {
    result->result->code_retour = -1;
  }

  return retour;
}


float PlaqueInterface::getDistanceToFirstPoint( int x, int y, int x0, int y0 )
{
  if ( g_pCurrentScale && !m_image.IsNull() )
  {
    Point pt( x, y );
    Point pt0( x0, y0 );
    return (float)g_pCurrentScale->Distance( pt, pt0 );
  }
  
  return 0.0f;
}

int PlaqueInterface::fonctionDebug( CPlaqueResult* result )
{
  int retour;
  int i; 

  if ( !m_image.IsNull() && result )
  {
    CPlaqueBase cplaque;    
	
    retour = cplaque.TestFantome(&m_image, result);

    //  Remplissage des valeurs dans result
    result->result->code_retour = retour;
   
    result->result->code_debug1 = cplaque.m_debug1;
    result->result->code_debug2 = cplaque.m_debug2;
    result->result->code_debug3 = cplaque.m_debug3;
    result->result->code_debug4 = cplaque.m_debug4;
    result->result->code_debug5 = cplaque.m_debug5;
    
    result->result->m_type = cplaque.m_type; 
    result->result->m_Etape = cplaque.m_Etape;
    
    result->result->plaque_max_thickness = cplaque.Max();
    result->result->plaque_mean_thickness = cplaque.Mean();
    result->result->plaque_area = cplaque.Surface();
    result->result->plaque_mean_density = cplaque.Density();
     
    result->result->numberOfMeasures = cplaque.m_nMesures;
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
//    result->result->m_nPtList = cplaque.m_nPtList;

    result->result->m_ptInferieur.x = cplaque.m_ptInferieur.x;
    result->result->m_ptInferieur.y = cplaque.m_ptInferieur.y;

	if ( result->result->m_tPtLongeantPlaque )
    {
      delete[] result->result->m_tPtLongeantPlaque;
    }
     
	result->result->m_tPtLongeantPlaque = new plaque::Point[ cplaque.m_nPtLongeantPlaque ];
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
      
    for ( i = 0; i < cplaque.m_nPtLongeantPlaque; i++ )
    {
      result->result->m_tPtLongeantPlaque[ i ].x = cplaque.m_tPtLongeantPlaque[ i ].x;
      result->result->m_tPtLongeantPlaque[ i ].y = cplaque.m_tPtLongeantPlaque[ i ].y;
    }
	//-----------
	if ( result->result->m_tbPtsTrouvesFin )
    {
      delete[] result->result->m_tbPtsTrouvesFin;
    }
     
	result->result->m_tbPtsTrouvesFin = new plaque::Point[ cplaque.m_nVecteursTrouves ];
    result->result->m_nVecteursTrouves = cplaque.m_nVecteursTrouves;
      
    for ( i = 0; i < cplaque.m_nVecteursTrouves; i++ )
    {
      result->result->m_tbPtsTrouvesFin[ i ].x = cplaque.m_tbPtsTrouvesFin[ i ].x;
      result->result->m_tbPtsTrouvesFin[ i ].y = cplaque.m_tbPtsTrouvesFin[ i ].y;
    }
 
//  Point	*m_ptList;
  }
  else
  {
    result->result->code_retour = -1;
  }

  return retour;
}

int PlaqueInterface::CalculerPlaqueManuelle(int nbPts, unsigned char *points, CPlaqueResult* result )
{
  int retour;

  if ( !m_image.IsNull() && result )
  {
    CPlaqueBase cplaque;    
	
    retour = cplaque.calculPlaque2(&m_image, nbPts, points);

    //  Remplissage des valeurs dans result
    result->result->code_retour = retour;
   
    result->result->code_debug1 = cplaque.m_debug1;
    result->result->code_debug2 = cplaque.m_debug2;
    result->result->code_debug3 = cplaque.m_debug3;
    result->result->code_debug4 = cplaque.m_debug4;
    result->result->code_debug5 = cplaque.m_debug5;
    
    result->result->m_type = cplaque.m_type; 
    result->result->m_Etape = cplaque.m_Etape;
    
    result->result->plaque_max_thickness = cplaque.Max();
    result->result->plaque_mean_thickness = cplaque.Mean();
    result->result->plaque_area = cplaque.Surface();
    result->result->plaque_mean_density = cplaque.Density();
    result->result->numberOfMeasures = cplaque.m_nMesures;
    
   result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
//    result->result->m_nPtList = cplaque.m_nPtList;

 //   result->result->m_ptInferieur.x = cplaque.m_ptInferieur.x;
//    result->result->m_ptInferieur.y = cplaque.m_ptInferieur.y;

/*
	if ( result->result->m_tPtLongeantPlaque )
    {
      delete[] result->result->m_tPtLongeantPlaque;
    }
     
	result->result->m_tPtLongeantPlaque = new plaque::Point[ cplaque.m_nPtLongeantPlaque ];
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
      
    for ( i = 0; i < cplaque.m_nPtLongeantPlaque; i++ )
    {
      result->result->m_tPtLongeantPlaque[ i ].x = cplaque.m_tPtLongeantPlaque[ i ].x;
      result->result->m_tPtLongeantPlaque[ i ].y = cplaque.m_tPtLongeantPlaque[ i ].y;
    }
	//-----------
	if ( result->result->m_tbPtsTrouvesFin )
    {
      delete[] result->result->m_tbPtsTrouvesFin;
    }
     
	result->result->m_tbPtsTrouvesFin = new plaque::Point[ cplaque.m_nVecteursTrouves ];
    result->result->m_nVecteursTrouves = cplaque.m_nVecteursTrouves;
      
    for ( i = 0; i < cplaque.m_nVecteursTrouves; i++ )
    {
      result->result->m_tbPtsTrouvesFin[ i ].x = cplaque.m_tbPtsTrouvesFin[ i ].x;
      result->result->m_tbPtsTrouvesFin[ i ].y = cplaque.m_tbPtsTrouvesFin[ i ].y;
    }
*/ 
//  Point	*m_ptList;
  }
  else
  {
    result->result->code_retour = -1;
  }

  return retour;
}

int PlaqueInterface::OnLButtonUp( int x, int y, CPlaqueResult* result )
{
  int retour;
  int i; 

  if ( !m_image.IsNull() && result )
  {
    CPlaqueBase cplaque;
    retour = cplaque.OnLButtonUp(&m_image, x, y);

    //  Remplissage des valeurs dans result
    result->result->code_retour = retour;
    
    result->result->code_debug1 = cplaque.m_debug1;
    result->result->code_debug2 = cplaque.m_debug2;
    result->result->code_debug3 = cplaque.m_debug3;
    result->result->code_debug4 = cplaque.m_debug4;
    result->result->code_debug5 = cplaque.m_debug5;

    result->result->m_type = cplaque.m_type; 
    result->result->m_Etape = cplaque.m_Etape;
    
    result->result->plaque_max_thickness = cplaque.Max();
    result->result->plaque_mean_thickness = cplaque.Mean();
    result->result->plaque_area = cplaque.Surface();
    result->result->plaque_mean_density = cplaque.Density();
     
    result->result->numberOfMeasures = cplaque.m_nMesures;
    result->result->m_nPtLongeantPlaque = cplaque.m_nPtLongeantPlaque;
//    result->result->m_nPtList = cplaque.m_nPtList;

    result->result->m_ptInferieur.x = cplaque.m_ptInferieur.x;
    result->result->m_ptInferieur.y = cplaque.m_ptInferieur.y;
        
    for ( i = 0; i < cplaque.m_nPtLongeantPlaque; i++ )
    {
 //     result->result->m_tPtLongeantPlaque[ i ].x = cplaque.m_tPtLongeantPlaque[ i ].x;
  //    result->result->m_tPtLongeantPlaque[ i ].y = cplaque.m_tPtLongeantPlaque[ i ].y;
    }
 
  
//  Point	*m_ptList;
 
 
    return 1;
  }
  else
  {
    result->result->code_retour = -1;
  }

  return 0;
}

int PlaqueInterface::getImageWidth()
{
  return m_image.GetWidth();
}

int PlaqueInterface::getImageHeight()
{
  return m_image.GetHeight();
}

int PlaqueInterface::getImageBitsPerPixel()
{
  return m_image.GetBPP();
}

char* PlaqueInterface::getPixelArray()
{
  return (char*) m_image.GetBits();
}