imchar.cpp

3D Game Engine Design Source Code非常棒

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

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

// value to assign when a divide-by-zero occurs
char mgcImageChar::zero_divide_result = 0;

//===========================================================================
mgcImageChar::
mgcImageChar () :
	mgcImage(mgcChar::type)
{
}
//---------------------------------------------------------------------------
mgcImageChar::
mgcImageChar (int _dimensions, const int* initial) :
	mgcImage(mgcChar::type,_dimensions,initial)
{
}
//---------------------------------------------------------------------------
mgcImageChar::mgcImageChar (int _dimensions, int initial_all) :
	mgcImage(mgcChar::type,_dimensions,initial_all)
{
}
//---------------------------------------------------------------------------
mgcImageChar::
mgcImageChar (int _dimensions, int initial0, int initial1, ...) :
	mgcImage(mgcChar::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(mgcChar::type,_dimensions,initial);
	delete[] initial;
}
//---------------------------------------------------------------------------
mgcImageChar::
mgcImageChar (const mgcImage& image) :
	mgcImage(mgcChar::type,image.Dimensions(),image.Bounds())
{
	*(mgcImage*)this = image;
}
//---------------------------------------------------------------------------
mgcImageChar::
mgcImageChar (const mgcLattice& lattice) :
	mgcImage(mgcChar::type,lattice.Dimensions(),lattice.Bounds())
{
}
//---------------------------------------------------------------------------
mgcImageChar::
mgcImageChar (char* fname) :
	mgcImage(mgcChar::type)
{
	Load(fname);
}
//---------------------------------------------------------------------------
mgcImage& mgcImageChar::
Load (char* fname, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcChar::type;
	mgcImage::Load(fname,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImage& mgcImageChar::
Save (char* fname, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcChar::type;
	mgcImage::Save(fname,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImage& mgcImageChar::
SaveAs (char* fname, int ff, int trgt)
{
	if ( trgt == -1 )
		trgt = mgcChar::type;
	mgcImage::SaveAs(fname,ff,trgt);
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator= (const mgcImageChar& image)
{
	if ( *(mgcLattice*)this != *(mgcLattice*)&image ) {
		*(mgcImage*)this = image;
		return *this;
	}

	memcpy(data,image.data,size*quantity);
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator= (const mgcImage& image)
{
	*(mgcImage*)this = image;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator= (char value)
{
	if ( data )
		for (int i = 0; i < quantity; i++)
			(*this)[i] = value;
	else
		Report(null_pixel_pointer);
	return *this;
}
//---------------------------------------------------------------------------
int mgcImageChar::
operator== (const mgcImage& image)
{
	return *(mgcImage*)this == image;
}
//---------------------------------------------------------------------------
int mgcImageChar::
operator== (char 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;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator+= (const mgcImageChar &image)
{
	if ( *(mgcLattice*)this != image ) {
		Report(incompatible_images);
		return *this;
	}

	for (int i = 0; i < quantity; i++)
		(*this)[i] += image[i];
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator-= (const mgcImageChar &image)
{
	if ( *(mgcLattice*)this != image ) {
		Report(incompatible_images);
		return *this;
	}

	for (int i = 0; i < quantity; i++)
		(*this)[i] -= image[i];
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator*= (const mgcImageChar &image)
{
	if ( *(mgcLattice*)this != image ) {
		Report(incompatible_images);
		return *this;
	}

	for (int i = 0; i < quantity; i++)
		(*this)[i] *= image[i];
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator/= (const mgcImageChar &image)
{
	if ( *(mgcLattice*)this != image ) {
		Report(incompatible_images);
		return *this;
	}

	for (int i = 0; i < quantity; i++)
		if ( image[i] != 0 )
			(*this)[i] /= image[i];
		else
			(*this)[i] = zero_divide_result;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator+= (char value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] += value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator-= (char value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] -= value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator*= (char value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] *= value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar& mgcImageChar::
operator/= (char value)
{
	for (int i = 0; i < quantity; i++)
		if ( value != 0 )
			(*this)[i] /= value;
		else
			(*this)[i] = zero_divide_result;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator- ()
{
	mgcImageChar result = *this;
	for (int i = 0; i < quantity; i++)
		result[i] = -result[i];  // conversion may lose significant digits
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator+ (const mgcImageChar &image)
{
	mgcImageChar result = *this;
	result += image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator- (const mgcImageChar &image)
{
	mgcImageChar result = *this;
	result -= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator* (const mgcImageChar &image)
{
	mgcImageChar result = *this;
	result *= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator/ (const mgcImageChar &image)
{
	mgcImageChar result = *this;
	result /= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator+ (char value)
{
	mgcImageChar result = *this;
	result += value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator- (char value)
{
	mgcImageChar result = *this;
	result -= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator* (char value)
{
	mgcImageChar result = *this;
	result *= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar mgcImageChar::
operator/ (char value)
{
	mgcImageChar result = *this;
	result /= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageChar
operator+ (char value, mgcImageChar &image)
{
	return image+value;
}
//---------------------------------------------------------------------------
mgcImageChar
operator- (char value, mgcImageChar &image)
{
	return -image+value;
}
//---------------------------------------------------------------------------
mgcImageChar
operator* (char value, mgcImageChar &image)
{
	return image*value;
}
//---------------------------------------------------------------------------
mgcImageChar
operator/ (char value, mgcImageChar &image)
{
	mgcImageChar result(image.Dimensions(),image.Bounds());
	result = value;
	result /= image;
	return result;
}
//---------------------------------------------------------------------------
void mgcImageChar::
ComputeMaxMin ()
{
	minimum = maximum = (*this)[0];

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

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

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