imushort.cpp

3D Game Engine Design Source Code非常棒

#include <fstream.h>
#include <string.h>
#include "imushort.h"

// error handling
int mgcImageUshort::verbose = 0;
unsigned mgcImageUshort::error = 0;
const unsigned mgcImageUshort::zero_dimension      = 0x00000001;
const unsigned mgcImageUshort::invalid_dimension   = 0x00000002;
const unsigned mgcImageUshort::null_pixel_pointer  = 0x00000004;
const unsigned mgcImageUshort::get_data_failed     = 0x00000008;
const unsigned mgcImageUshort::put_data_failed     = 0x00000010;
const unsigned mgcImageUshort::load_failed         = 0x00000020;
const unsigned mgcImageUshort::save_failed         = 0x00000040;
const char* mgcImageUshort::message[7] = {
	"zero dimension in argument list",
	"invalid dimension in variable argument list",
	"null pointer in assignment",
	"attempt to read file data failed",
	"attempt to write file data failed",
	"attempt to load file failed",
	"attempt to save file failed"
};

//===========================================================================
mgcImageUshort::
mgcImageUshort () :
	mgcImage(mgcUshort::type)
{
}
//---------------------------------------------------------------------------
mgcImageUshort::
mgcImageUshort (int _dimensions, const int* initial) :
	mgcImage(mgcUshort::type,_dimensions,initial)
{
}
//---------------------------------------------------------------------------
mgcImageUshort::mgcImageUshort (int _dimensions, int initial_all) :
	mgcImage(mgcUshort::type,_dimensions,initial_all)
{
}
//---------------------------------------------------------------------------
mgcImageUshort::
mgcImageUshort (int _dimensions, int initial0, int initial1, ...) :
	mgcImage(mgcUshort::type)
{
	if ( _dimensions < 2 ) {
		Report(invalid_dimension);
		return;
	}

	int* initial = new int[_dimensions];
	initial[0] = initial0;
	initial[1] = initial1;

	va_list ap;
	va_start(ap,initial1);
	for (int d = 2; d < _dimensions; d++)
		initial[d] = va_arg(ap,int);
	va_end(ap);

	*(mgcImage*)this = mgcImage(mgcUshort::type,_dimensions,initial);
	delete[] initial;
}
//---------------------------------------------------------------------------
mgcImageUshort::
mgcImageUshort (const mgcImage& image) :
	mgcImage(mgcUshort::type,image.Dimensions(),image.Bounds())
{
	*(mgcImage*)this = image;
}
//---------------------------------------------------------------------------
mgcImageUshort::
mgcImageUshort (const mgcLattice& lattice) :
	mgcImage(mgcUshort::type,lattice.Dimensions(),lattice.Bounds())
{
}
//---------------------------------------------------------------------------
mgcImageUshort::
mgcImageUshort (char* fname) :
	mgcImage(mgcUshort::type)
{
	Load(fname);
}
//---------------------------------------------------------------------------
mgcImage& mgcImageUshort::
Load (char* fname, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcUshort::type;
	mgcImage::Load(fname,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImage& mgcImageUshort::
Save (char* fname, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcUshort::type;
	mgcImage::Save(fname,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImage& mgcImageUshort::
SaveAs (char* fname, int ff, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcUshort::type;
	mgcImage::SaveAs(fname,ff,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImageUshort& mgcImageUshort::
operator= (const mgcImageUshort& image)
{
	if ( *(mgcLattice*)this != *(mgcLattice*)&image ) {
		*(mgcImage*)this = image;
		return *this;
	}

	memcpy(data,image.data,size*quantity);
	return *this;
}
//---------------------------------------------------------------------------
mgcImageUshort& mgcImageUshort::
operator= (const mgcImage& image)
{
	*(mgcImage*)this = image;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageUshort& mgcImageUshort::
operator= (unsigned short value)
{
	if ( data )
		for (int i = 0; i < quantity; i++)
			(*this)[i] = value;
	else
		Report(null_pixel_pointer);
	return *this;
}
//---------------------------------------------------------------------------
int mgcImageUshort::
operator== (const mgcImage& image)
{
	return *(mgcImage*)this == image;
}
//---------------------------------------------------------------------------
int mgcImageUshort::
operator== (unsigned short value)
{
	if ( data == 0 ) {
		Report(null_pixel_pointer);
		return 0;
	}

	for (int i = 0; i < quantity; i++)
		if ( (*this)[i] != value )
			return 0;
	return 1;
}
//---------------------------------------------------------------------------
void mgcImageUshort::
ComputeMaxMin ()
{
	minimum = maximum = (*this)[0];

	for (int i = 1; i < quantity; i++) {
		unsigned short value = (*this)[i];
		if ( value < minimum )
			minimum = value;
		else if ( value > maximum )
			maximum = value;
	}
}
//---------------------------------------------------------------------------
int mgcImageUshort::
Number (unsigned single_error)
{
	int result;
	for (result = -1; single_error; single_error >>= 1)
		result++;
	return result;
}
//---------------------------------------------------------------------------
void mgcImageUshort::
Report (unsigned single_error)
{
	if ( verbose || mgcImage::verbose || mgcLattice::verbose )
		cout << "mgcImageUshort: " << message[Number(single_error)] << endl;
	else
		ofstream("imushort.err",ios::out|ios::app)
			 << "mgcImageUshort: " << message[Number(single_error)] << endl;

	error |= single_error;
}
//---------------------------------------------------------------------------
void mgcImageUshort::
Report (ostream& ostr)
{
	for (unsigned single_error = 1; single_error; single_error <<= 1)
		if ( error & single_error )
			ostr << "mgcImageUshort: " << message[Number(single_error)]
				 << endl;

	error = 0;
}
//===========================================================================