imint.cpp

3D Game Engine Design Source Code非常棒

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

// error handling
int mgcImageInt::verbose = 0;
unsigned mgcImageInt::error = 0;
const unsigned mgcImageInt::zero_dimension      = 0x00000001;
const unsigned mgcImageInt::invalid_dimension   = 0x00000002;
const unsigned mgcImageInt::null_pixel_pointer  = 0x00000004;
const unsigned mgcImageInt::incompatible_images = 0x00000008;
const unsigned mgcImageInt::get_data_failed     = 0x00000010;
const unsigned mgcImageInt::put_data_failed     = 0x00000020;
const unsigned mgcImageInt::load_failed         = 0x00000040;
const unsigned mgcImageInt::save_failed         = 0x00000080;
const char* mgcImageInt::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
int mgcImageInt::zero_divide_result = 0;

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

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

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

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

	for (int i = 0; i < quantity; i++)
		(*this)[i] *= image[i];
	return *this;
}
//---------------------------------------------------------------------------
mgcImageInt& mgcImageInt::
operator/= (const mgcImageInt &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;
}
//---------------------------------------------------------------------------
mgcImageInt& mgcImageInt::
operator+= (int value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] += value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageInt& mgcImageInt::
operator-= (int value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] -= value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageInt& mgcImageInt::
operator*= (int value)
{
	for (int i = 0; i < quantity; i++)
		(*this)[i] *= value;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageInt& mgcImageInt::
operator/= (int value)
{
	for (int i = 0; i < quantity; i++)
		if ( value != 0 )
			(*this)[i] /= value;
		else
			(*this)[i] = zero_divide_result;
	return *this;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator- ()
{
	mgcImageInt result = *this;
	for (int i = 0; i < quantity; i++)
		result[i] = -result[i];
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator+ (const mgcImageInt &image)
{
	mgcImageInt result = *this;
	result += image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator- (const mgcImageInt &image)
{
	mgcImageInt result = *this;
	result -= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator* (const mgcImageInt &image)
{
	mgcImageInt result = *this;
	result *= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator/ (const mgcImageInt &image)
{
	mgcImageInt result = *this;
	result /= image;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator+ (int value)
{
	mgcImageInt result = *this;
	result += value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator- (int value)
{
	mgcImageInt result = *this;
	result -= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator* (int value)
{
	mgcImageInt result = *this;
	result *= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt mgcImageInt::
operator/ (int value)
{
	mgcImageInt result = *this;
	result /= value;
	return result;
}
//---------------------------------------------------------------------------
mgcImageInt
operator+ (int value, mgcImageInt &image)
{
	return image+value;
}
//---------------------------------------------------------------------------
mgcImageInt
operator- (int value, mgcImageInt &image)
{
	return -image+value;
}
//---------------------------------------------------------------------------
mgcImageInt
operator* (int value, mgcImageInt &image)
{
	return image*value;
}
//---------------------------------------------------------------------------
mgcImageInt
operator/ (int value, mgcImageInt &image)
{
	mgcImageInt result(image.Dimensions(),image.Bounds());
	result = value;
	result /= image;
	return result;
}
//---------------------------------------------------------------------------
void mgcImageInt::
ComputeMaxMin ()
{
	minimum = maximum = (*this)[0];

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

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

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