MAth-Cloud-3.0.0/www.ipsocloud.com/intimamedia.com/cpp/MAth-Plaque-Dll-1.0.0/LibPlaque/Container/extendedimage.cpp

#include "ExtendedImage.h"
#include <cstdio>

#if !defined( WIN32 ) || defined( IMT_DLL ) || defined( PLAQUE_DLL )
#include <cstring>
#endif

#include <fstream>

ExtendedImage::ExtendedImage()
#if defined( WIN32 ) && !defined( IMT_DLL ) && !defined( PLAQUE_DLL )
  : CImage(),
	m_resX( 1.0 ),
	m_resY( 1.0 )
#else
  : m_resX( 1.0 ),
	m_resY( 1.0 ),
	m_width( 0 ),
	m_height( 0 ),
	m_bpp( 0 ),
	m_buffer( NULL )
#endif
{
}

#if !defined( WIN32 ) || defined( IMT_DLL ) || defined( PLAQUE_DLL )
ExtendedImage::~ExtendedImage()
{
  Destroy();
}

bool ExtendedImage::Create( int width, int height, int bpp )
{
  unsigned long n = width * height * bpp / 8;

  m_width = width;
  m_height = height;
  m_bpp = bpp;
  m_buffer = new char[ n ];
  
  if ( !m_buffer )
  {
    return false;
  }

  return true;
}

void ExtendedImage::Destroy()
{
  delete[] m_buffer;
  
  m_buffer = NULL;
  m_width = 0;
  m_height = 0;
  m_bpp = 0;
  m_resX = 1.0;
  m_resY = 1.0;
}

bool ExtendedImage::IsNull()
{
  return m_buffer ? false : true;
}

bool ExtendedImage::SetRaw( char* buffer, unsigned long n )
{
  if ( buffer )
  {
    int bpp = m_bpp / 8;
    unsigned long deltaH = ( n / bpp ) % m_height;
    unsigned long scanline = m_width * bpp;
    
    int i = m_height;
    char* bptr = m_buffer;
    char* iptr = buffer;
    
    while ( i-- )
    {
      std::memcpy( bptr, iptr, scanline );
      bptr += scanline;
      iptr += scanline + deltaH;
    }
  
    return true;
  }
  
  return false;
}

char* ExtendedImage::GetBits()
{
  return m_buffer;
}

unsigned char ExtendedImage::GetPixelRGB( int x, int y, int channel )
{
	unsigned char *dadd; 
	int n = m_bpp / 8;
 
	int scanline = ( ( m_width * n ) + 3 ) & ~3;
	dadd = (unsigned char *) m_buffer + ( scanline * y ) + (n * x);

	if (channel == 0) // Rouge
	{
	}
	else if (channel == 1) // Vert 
	{
		dadd += 1; 
	}
	else if (channel == 2) // Bleu 
	{
		dadd += 2;
	}

	return (*dadd);
} 

int ExtendedImage::GetPixelGray( int x, int y)
{
	int r, v, b, moy;
	unsigned char* dadd; 
	int n = m_bpp / 8;

	int scanline = ( ( m_width * n ) + 3 ) & ~3;
	dadd = (unsigned char*) m_buffer + ( scanline * y ) + (n * x) ;

	r = (int) * dadd;
	dadd++;

	v = (int) * dadd;
	dadd++;

	b = (int) * dadd;

	moy = (r + v + b) / 3; 

	return moy;
} 

#endif

bool ExtendedImage::HasCalibration()
{
  return ( ( m_resX > 0.0 ) && ( m_resY > 0.0 ) );
}

void ExtendedImage::SetResolution( double resX, double resY )
{
	m_resX = resX;
	m_resY = resY;
}

void ExtendedImage::CopyFrom2(ExtendedImage *vSource)
{
	unsigned char *dadd, *amax,*dadd1;
	int scanline = ( ( m_width * m_bpp / 8 ) + 3 ) & ~3;

    dadd = (unsigned char *) m_buffer;
	amax = dadd + (scanline * m_height);
    dadd1 = (unsigned char *) vSource->m_buffer;
	while (dadd < amax)
	{
		*dadd = *dadd1;
		dadd++;
		dadd1++;
	}
}

void ExtendedImage::Copy2(int dimh, int dimv, ExtendedImage *vSource)
{
	char* imgPtr = (char*) GetBits();
	char* imgPtrSrc = (char*) vSource->GetBits();

	memcpy(imgPtr, imgPtrSrc, (size_t) (dimh * dimv * 3 * sizeof(unsigned char)));
}

void ExtendedImage::SaveImgAsRaw() 
{
	int n = m_bpp / 8;

	std::ofstream ofs( "C:\\Image.raw", std::ios_base::out | std::ios_base::binary  );
	if ( ofs.good() )
	{
		int scanline = ( ( m_width * n) + 3 ) & ~3;
		ofs.write( (char*) m_buffer, scanline * m_height );
		ofs.close();
	}
}