gtkradiant/tools/quake2/qdata_heretic2/animcomp.c

/*
   Copyright (C) 1999-2007 id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */


#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <memory.h>
#include "animcomp.h"


void    *SafeMalloc( size_t n, char *desc );



float *matrix;
float *delta;
float *best;
float *comp;
float *tcomp;
float *bestcomp;
float *frames;
float *base;

int MatWidth;
int MatHeight;
int CFrameSize;
int nFrames;


void AnimCompressInit( int nframes,int nVerts,int CompressedFrameSize ){
	nFrames = nframes;
	MatWidth = nVerts * 3;
	MatHeight = CompressedFrameSize;
	CFrameSize = CompressedFrameSize;
	matrix = (float *)SafeMalloc( MatWidth * MatHeight * sizeof( float ), "AnimCompressInit" );
	best = (float *)SafeMalloc( MatWidth * MatHeight * sizeof( float ), "AnimCompressInit" );
	delta = (float *)SafeMalloc( MatWidth * MatHeight * sizeof( float ), "AnimCompressInit" );
	comp = (float *)SafeMalloc( CFrameSize * nFrames * sizeof( float ), "AnimCompressInit" );
	tcomp = (float *)SafeMalloc( CFrameSize * nFrames * sizeof( float ), "AnimCompressInit" );
	bestcomp = (float *)SafeMalloc( CFrameSize * nFrames * sizeof( float ), "AnimCompressInit" );
	base = (float *)SafeMalloc( MatWidth * sizeof( float ), "AnimCompressInit" );
	frames = (float *)SafeMalloc( MatWidth * nFrames * sizeof( float ), "AnimCompressInit" );
}

void AnimSetFrame( int frame,int index,float x,float y,float z ){
	frames[frame * MatWidth + index * 3] = x;
	frames[frame * MatWidth + index * 3 + 1] = y;
	frames[frame * MatWidth + index * 3 + 2] = z;
}

typedef struct
{
	int index;
	float val;
} SORTP;


#define F_RANDOM ( ( (float)rand() ) / (float)RAND_MAX )

extern void DOsvd( float *a,float *res,float *comp,float *values,int nframes,int framesize,int compressedsize );

void AnimCompressDoit(){
	float compression;
	float *rescale;
	float *ans;
	float maxdev;
	float avedev;
	float tmp;
	int j,k,l,numave;

	for ( k = 0; k < MatWidth; k++ )
		base[k] = 0.0f;
	for ( j = 0; j < nFrames; j++ )
		for ( k = 0; k < MatWidth; k++ )
			base[k] += frames[j * MatWidth + k];
	tmp = 1.0f / (float)nFrames;
	for ( k = 0; k < MatWidth; k++ )
		base[k] *= tmp;
	for ( j = 0; j < nFrames; j++ )
		for ( k = 0; k < MatWidth; k++ )
			frames[j * MatWidth + k] -= base[k];

	ans = (float *)SafeMalloc( sizeof( float ) * MatWidth, "AnimCompressDoit" );
	rescale = (float *)SafeMalloc( sizeof( float ) * CFrameSize, "AnimCompressDoit" );
	DOsvd( frames,best,bestcomp,rescale,nFrames,MatWidth,MatHeight );
	avedev = 0.0;
	for ( l = 0; l < CFrameSize; l++ )
		avedev += rescale[l];
	for ( l = 0; l < CFrameSize; l++ )
		printf( "%3.1f ",100.0f * rescale[l] / avedev );
	printf( "\n" );
	for ( j = 0; j < nFrames; j++ )
	{
		for ( l = 0; l < CFrameSize; l++ )
		{
			bestcomp[j * CFrameSize + l] = 0.0;
			for ( k = 0; k < MatWidth; k++ )
				bestcomp[j * CFrameSize + l] += best[l * MatWidth + k] * frames[j * MatWidth + k];
		}
	}
	numave = 0;
	avedev = 0.0;
	maxdev = 0.0;
	for ( j = 0; j < nFrames; j++ )
	{
		for ( k = 0; k < MatWidth; k++ )
		{
			ans[k] = 0.0;
			for ( l = 0; l < CFrameSize; l++ )
				ans[k] += best[l * MatWidth + k] * bestcomp[j * CFrameSize + l];
			ans[k] -= frames[j * MatWidth + k];
			tmp = (float)fabs( ans[k] );
			if ( tmp > maxdev ) {
				maxdev = tmp;
			}
			avedev += tmp;
			numave++;
		}
	}
	avedev /= (float)numave;
	printf( "%f Max Deviation (inches)  %f Ave Dev. (inches)\n",maxdev,avedev );
	printf( "%d bytes original size\n",MatWidth * nFrames );
	printf( "%d bytes of overhead\n",MatWidth * MatHeight );
	printf( "%d bytes/frame * %d frames = %d bytes\n",CFrameSize,nFrames,CFrameSize * nFrames );
	compression = (float)( MatWidth * MatHeight + CFrameSize * nFrames + MatWidth );
	compression /= (float)( MatWidth * nFrames );
	printf( "Overall compression = %f %%\n",100.0f - 100.0f * compression );
	compression = (float)( CFrameSize );
	compression /= (float)( MatWidth );
	printf( "frame size compression = %f %%\n",100.0f - 100.0f * compression );
	free( rescale );
	free( ans );
}

void AnimCompressToBytes( float *trans,float *scale,char *mat,char *ccomp,unsigned char *cbase,float *cscale,float *coffset,float *bmin,float *bmax ){
	int k,l,nv,j;
	float maxdev;
	float avedev;
	float tmp;
	int numave;
	float t,mx;
	float *ans;


	nv = MatWidth / 3;

	trans[0] = 1E30f;
	scale[0] = -1E30f;
	trans[1] = 1E30f;
	scale[1] = -1E30f;
	trans[2] = 1E30f;
	scale[2] = -1E30f;
	for ( k = 0; k < MatWidth; k += 3 )
	{
		if ( base[k] > scale[0] ) {
			scale[0] = base[k];
		}
		if ( base[k] < trans[0] ) {
			trans[0] = base[k];
		}

		if ( base[k + 1] > scale[1] ) {
			scale[1] = base[k + 1];
		}
		if ( base[k + 1] < trans[1] ) {
			trans[1] = base[k + 1];
		}

		if ( base[k + 2] > scale[2] ) {
			scale[2] = base[k + 2];
		}
		if ( base[k + 2] < trans[2] ) {
			trans[2] = base[k + 2];
		}
	}

	scale[0] -= trans[0];
	scale[1] -= trans[1];
	scale[2] -= trans[2];
	scale[0] /= 255.0f;
	scale[1] /= 255.0f;
	scale[2] /= 255.0f;
	for ( k = 0; k < MatWidth; k += 3 )
	{
		t = ( base[k] - trans[0] ) / scale[0];
		if ( t < 0.0f ) {
			t = 0.0f;
		}
		if ( t > 255.0f ) {
			t = 255.0f;
		}
		cbase[k] = (unsigned char)t;

		t = ( base[k + 1] - trans[1] ) / scale[1];
		if ( t < 0.0f ) {
			t = 0.0f;
		}
		if ( t > 255.0f ) {
			t = 255.0f;
		}
		cbase[k + 1] = (unsigned char)t;

		t = ( base[k + 2] - trans[2] ) / scale[2];
		if ( t < 0.0f ) {
			t = 0.0f;
		}
		if ( t > 255.0f ) {
			t = 255.0f;
		}
		cbase[k + 2] = (unsigned char)t;
	}
	for ( l = 0; l < MatHeight; l++ )
	{
		mx = 0.0;
		for ( k = 0; k < MatWidth; k++ )
		{
			if ( fabs( best[l * MatWidth + k] ) > mx ) {
				mx = (float)fabs( best[l * MatWidth + k] );
			}
		}
		if ( mx > 1E-8 ) {
			mx /= 127.0f;
			coffset[l] = 1E30f;
			cscale[l] = -1E30f;
			for ( j = 0; j < nFrames; j++ )
			{
				bestcomp[j * MatHeight + l] *= mx;
				if ( bestcomp[j * MatHeight + l] > cscale[l] ) {
					cscale[l] = bestcomp[j * MatHeight + l];
				}
				if ( bestcomp[j * MatHeight + l] < coffset[l] ) {
					coffset[l] = bestcomp[j * MatHeight + l];
				}
			}
			cscale[l] -= coffset[l];
			if ( cscale[l] > 1E-10 ) {
				for ( j = 0; j < nFrames; j++ )
				{
					tmp = 254.0f * ( bestcomp[j * MatHeight + l] - coffset[l] ) / cscale[l] - 127.0f;
					if ( tmp > 127.0f ) {
						tmp = 127.0f;
					}
					if ( tmp < -127.0f ) {
						tmp = -127.0f;
					}
					ccomp[j * MatHeight + l] = (char)floor( tmp + 0.5 );
				}
				coffset[l] += cscale[l] * 127.0f / 254.0f;
				cscale[l] /= 254.0f;
			}
			else
			{
				cscale[l] = 1.0f;
				coffset[l] = 0.0f;
				for ( j = 0; j < nFrames; j++ )
					ccomp[j * MatHeight + l] = 0;
			}
			mx = 1.0f / mx;
			for ( k = 0; k < MatWidth; k++ )
			{
				tmp = best[l * MatWidth + k] * mx;
				if ( tmp > 127.0f ) {
					tmp = 127.0f;
				}
				if ( tmp < -127.0f ) {
					tmp = -127.0f;
				}
				mat[k * MatHeight + l] = (char)floor( tmp + 0.5 );
			}
		}
		else
		{
			cscale[l] = 1.0f;
			coffset[l] = 0.0f;
			for ( j = 0; j < nFrames; j++ )
				ccomp[j * MatHeight + l] = 0;
			for ( k = 0; k < MatWidth; k++ )
				mat[k * MatHeight + l] = 0;
		}
	}
	bmin[0] = 1E30f;
	bmin[1] = 1E30f;
	bmin[2] = 1E30f;
	bmax[0] = -1E30f;
	bmax[1] = -1E30f;
	bmax[2] = -1E30f;
	numave = 0;
	avedev = 0.0;
	maxdev = 0.0;
	ans = (float *)SafeMalloc( sizeof( float ) * MatWidth, "AnimCompressToBytes" );
	for ( j = 0; j < nFrames; j++ )
	{
		for ( k = 0; k < MatWidth; k++ )
		{
			ans[k] = 0.0;
			for ( l = 0; l < CFrameSize; l++ )
				ans[k] += (float)( mat[l + k * MatHeight] ) * ( (float)( ccomp[j * CFrameSize + l] ) * cscale[l] + coffset[l] );
			ans[k] += (float)( cbase[k] ) * scale[k % 3] + trans[k % 3];
			tmp = (float)fabs( ans[k] - frames[j * MatWidth + k] - base[k] );
			if ( tmp > maxdev ) {
				maxdev = tmp;
			}
			avedev += tmp;
			numave++;

			if ( bmin[k % 3] > ans[k] ) {
				bmin[k % 3] = ans[k];
			}
			if ( bmax[k % 3] < ans[k] ) {
				bmax[k % 3] = ans[k];
			}
		}
	}
	avedev /= (float)numave;
	printf( "%f Max Deviation (inches)  %f Ave Dev. (inches)\n",maxdev,avedev );
	free( ans );
}

void AnimCompressGetMatrix( float *mat ){
	int k,l;
	for ( k = 0; k < MatWidth; k++ )
		for ( l = 0; l < MatHeight; l++ )
			mat[k * MatHeight + l] = best[l * MatWidth + k];
}

void AnimCompressGetFrames( float *mat ){
	memcpy( mat,bestcomp,CFrameSize * nFrames * sizeof( float ) );
}

void AnimCompressGetBase( int i,float *x,float *y,float *z ){
	*x = base[i * 3];
	*y = base[i * 3 + 1];
	*z = base[i * 3 + 2];
}

void AnimCompressEnd(){
	free( matrix );
	free( best );
	free( delta );
	free( comp );
	free( tcomp );
	free( bestcomp );
	free( base );
	free( frames );
}