imdouble.cpp

3D Game Engine Design Source Code非常棒

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

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

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

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

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

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

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

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

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

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