imshort.cpp

3D Game Engine Design Source Code非常棒

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

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

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

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

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

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

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

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

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

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