1619 lines
46 KiB
C++
1619 lines
46 KiB
C++
//===== Copyright © 1996-2006, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include <tier0/platform.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "bitmap/floatbitmap.h"
|
|
#include <tier2/tier2.h>
|
|
#include "bitmap/imageformat.h"
|
|
#include "bitmap/tgaloader.h"
|
|
#include "tier1/strtools.h"
|
|
#include "filesystem.h"
|
|
#include "vstdlib/jobthread.h"
|
|
|
|
// for PSD loading
|
|
#include "bitmap/bitmap.h"
|
|
#include "bitmap/psd.h"
|
|
#include "tier2/utlstreambuffer.h"
|
|
|
|
// NOTE: This has to be the last file included!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Globals
|
|
//-----------------------------------------------------------------------------
|
|
IThreadPool *FloatBitMap_t::sm_pFBMThreadPool = NULL;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets a thread pool for all float bitmap work to be done on
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::SetThreadPool( IThreadPool* pPool )
|
|
{
|
|
sm_pFBMThreadPool = pPool;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Utility methods
|
|
//-----------------------------------------------------------------------------
|
|
#define SQ(x) ((x)*(x))
|
|
|
|
// linear interpolate between 2 control points (L,R)
|
|
inline float LinInterp( float frac, float L, float R )
|
|
{
|
|
return ( ( ( R - L ) * frac ) + L );
|
|
}
|
|
|
|
// bilinear interpolate between 4 control points (UL,UR,LL,LR)
|
|
inline float BiLinInterp( float Xfrac, float Yfrac, float UL, float UR, float LL, float LR )
|
|
{
|
|
float iu = LinInterp( Xfrac, UL, UR );
|
|
float il = LinInterp( Xfrac, LL, LR );
|
|
return( LinInterp( Yfrac, iu, il ) );
|
|
}
|
|
|
|
// trilinear interpolate between 8 control points (ULN,URN,LLN,LRN,ULF,URF,LLF,LRF)
|
|
inline float TriLinInterp( float Xfrac, float Yfrac, float Zfrac, float ULN,
|
|
float URN, float LLN, float LRN, float ULF, float URF, float LLF, float LRF )
|
|
{
|
|
float iu = LinInterp( Xfrac, ULN, URN );
|
|
float il = LinInterp( Xfrac, LLN, LRN );
|
|
float jn =( LinInterp( Yfrac, iu, il ) );
|
|
|
|
iu = LinInterp( Xfrac, ULF, URF );
|
|
il = LinInterp( Xfrac, LLF, LRF );
|
|
float jf =( LinInterp( Yfrac, iu, il ) );
|
|
|
|
return( LinInterp( Zfrac, jn, jf ) );
|
|
}
|
|
|
|
static char GetChar( FileHandle_t & f )
|
|
{
|
|
char a;
|
|
g_pFullFileSystem->Read( &a, 1, f );
|
|
return a;
|
|
}
|
|
|
|
static int GetInt( FileHandle_t & f )
|
|
{
|
|
char buf[100];
|
|
char * bout = buf;
|
|
for( ; ; )
|
|
{
|
|
char c = GetChar( f );
|
|
if ( ( c <'0' ) || ( c >'9' ) )
|
|
break;
|
|
*( bout++ ) = c;
|
|
}
|
|
*( bout++ ) = 0;
|
|
return atoi( buf );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructors
|
|
//-----------------------------------------------------------------------------
|
|
FloatBitMap_t::FloatBitMap_t( int nWidth, int nHeight, int nDepth, int nAttributeMask )
|
|
{
|
|
Init( nWidth, nHeight, nDepth, nAttributeMask );
|
|
}
|
|
|
|
FloatBitMap_t::FloatBitMap_t( const FloatBitMap_t *pOrig )
|
|
{
|
|
Init( pOrig->NumCols(), pOrig->NumRows(), pOrig->NumSlices() );
|
|
LoadFromFloatBitmap( pOrig );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialize, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::Shutdown()
|
|
{
|
|
Purge();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Construct a floating point gamma table
|
|
//-----------------------------------------------------------------------------
|
|
static void ConstructFloatGammaTable( float* pTable, float flSrcGamma, float flDstGamma )
|
|
{
|
|
float flOO1023 = 1.0f / 1023.0f;
|
|
for( int i = 0; i < 1024; i++ )
|
|
{
|
|
pTable[i] = pow( (float)i * flOO1023, flSrcGamma / flDstGamma );
|
|
}
|
|
}
|
|
|
|
static void ConstructShortGammaTable( uint16* pTable, float flSrcGamma, float flDstGamma )
|
|
{
|
|
float flOO1023 = 1.0f / 1023.0f;
|
|
for( int i = 0; i < 1024; i++ )
|
|
{
|
|
pTable[i] = ( uint16 )( 1023.0f * pow( (float)i * flOO1023, flSrcGamma / flDstGamma ) + 0.5f );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the gamma table
|
|
//-----------------------------------------------------------------------------
|
|
static const float *GetFloatGammaTable( float flSrcGamma )
|
|
{
|
|
// Compute gamma tables...
|
|
static float s_pGammaToLinear[1024];
|
|
static float s_flLastSrcGamma = -1;
|
|
|
|
if ( s_flLastSrcGamma != flSrcGamma )
|
|
{
|
|
ConstructFloatGammaTable( s_pGammaToLinear, flSrcGamma, 1.0f );
|
|
s_flLastSrcGamma = flSrcGamma;
|
|
}
|
|
|
|
return s_pGammaToLinear;
|
|
}
|
|
|
|
static const uint16 *GetShortGammaTable( float flDestGamma )
|
|
{
|
|
// Compute gamma tables...
|
|
static uint16 s_pLinearToGamma[1024];
|
|
static float s_flLastDestGamma = -1;
|
|
|
|
if ( s_flLastDestGamma != flDestGamma )
|
|
{
|
|
ConstructShortGammaTable( s_pLinearToGamma, 1.0f, flDestGamma );
|
|
s_flLastDestGamma = flDestGamma;
|
|
}
|
|
|
|
return s_pLinearToGamma;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Loads from a buffer, assumes dimensions match the bitmap size
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::LoadFromBuffer( const void *pBuffer, size_t nBufSize, ImageFormat fmt, float flGamma )
|
|
{
|
|
if ( !pBuffer || !nBufSize )
|
|
return;
|
|
|
|
Assert( ImageLoader::GetMemRequired( NumCols(), NumRows(), NumSlices(), 1, fmt ) == (int)nBufSize );
|
|
if( ImageLoader::GetMemRequired( NumCols(), NumRows(), NumSlices(), 1, fmt ) != (int)nBufSize )
|
|
{
|
|
Warning( "FloatBitMap_t::LoadFromBuffer: Received improper buffer size, skipping!\n" );
|
|
return;
|
|
}
|
|
|
|
// Cache off constant values
|
|
float c[FBM_ATTR_COUNT] = { 0.0 };
|
|
int nMask = GetAttributeMask();
|
|
for ( int i = 0; i < FBM_ATTR_COUNT; ++i )
|
|
{
|
|
if ( ( nMask & ( 1 << i ) ) == 0 )
|
|
{
|
|
c[i] = ConstantValue( i );
|
|
}
|
|
}
|
|
|
|
switch( fmt )
|
|
{
|
|
case IMAGE_FORMAT_ABGR8888:
|
|
LoadFromBufferRGBA( ( const ABGR8888_t* )pBuffer, nBufSize / sizeof(ABGR8888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_RGBA8888:
|
|
LoadFromBufferRGBA( ( const RGBA8888_t* )pBuffer, nBufSize / sizeof(RGBA8888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGRA8888:
|
|
LoadFromBufferRGBA( ( const BGRA8888_t* )pBuffer, nBufSize / sizeof(BGRA8888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_RGB888:
|
|
LoadFromBufferRGB( ( const RGB888_t* )pBuffer, nBufSize / sizeof(RGB888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGR888:
|
|
LoadFromBufferRGB( ( const BGR888_t* )pBuffer, nBufSize / sizeof(BGR888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGRX8888:
|
|
LoadFromBufferRGB( ( BGRX8888_t* )pBuffer, nBufSize / sizeof(BGRX8888_t), GetFloatGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UV88:
|
|
LoadFromBufferUV( ( const UV88_t* )pBuffer, nBufSize / sizeof(UV88_t) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UVWQ8888:
|
|
LoadFromBufferUVWQ( ( const UVWQ8888_t* )pBuffer, nBufSize / sizeof(UVWQ8888_t) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UVLX8888:
|
|
LoadFromBufferUVLX( ( const UVLX8888_t* )pBuffer, nBufSize / sizeof(UVLX8888_t) );
|
|
break;
|
|
|
|
default:
|
|
Warning( "FloatBitMap_t::LoadFromBuffer: Unsupported color format, skipping!\n" );
|
|
Assert( 0 );
|
|
break;
|
|
}
|
|
|
|
// Restore constant values
|
|
for ( int i = 0; i < FBM_ATTR_COUNT; ++i )
|
|
{
|
|
if ( ( nMask & ( 1 << i ) ) == 0 )
|
|
{
|
|
FillAttr( i, c[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FloatBitMap_t::LoadFromFloatBitmap( const FloatBitMap_t *pOrig )
|
|
{
|
|
Assert( ( NumCols() == pOrig->NumCols() ) && ( NumRows() == pOrig->NumRows() ) && ( NumSlices() == pOrig->NumSlices() ) );
|
|
if ( ( NumCols() != pOrig->NumCols() ) || ( NumRows() != pOrig->NumRows() ) || ( NumSlices() != pOrig->NumSlices() ) )
|
|
{
|
|
Warning( "FloatBitMap_t::LoadFromFloatBitmap: Received improper bitmap size, skipping!\n" );
|
|
return;
|
|
}
|
|
|
|
float flDefaultVal[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
|
|
for ( int i = 0; i < 4; ++i )
|
|
{
|
|
if ( !HasAttributeData( (FBMAttribute_t)i ) )
|
|
{
|
|
FillAttr( i, flDefaultVal[i] );
|
|
}
|
|
else
|
|
{
|
|
CopyAttrFrom( *pOrig, i );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Writes into a buffer, assumes dimensions match the bitmap size
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::WriteToBuffer( void *pBuffer, size_t nBufSize, ImageFormat fmt, float flGamma ) const
|
|
{
|
|
if ( !pBuffer || !nBufSize )
|
|
return;
|
|
|
|
Assert( ImageLoader::GetMemRequired( NumCols(), NumRows(), NumSlices(), 1, fmt ) == (int)nBufSize );
|
|
if( ImageLoader::GetMemRequired( NumCols(), NumRows(), NumSlices(), 1, fmt ) != (int)nBufSize )
|
|
{
|
|
Warning( "FloatBitMap_t::WriteToBuffer: Received improper buffer size, skipping!\n" );
|
|
return;
|
|
}
|
|
|
|
switch( fmt )
|
|
{
|
|
case IMAGE_FORMAT_ABGR8888:
|
|
WriteToBufferRGBA( ( ABGR8888_t* )pBuffer, nBufSize / sizeof(ABGR8888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_RGBA8888:
|
|
WriteToBufferRGBA( ( RGBA8888_t* )pBuffer, nBufSize / sizeof(RGBA8888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGRA8888:
|
|
WriteToBufferRGBA( ( BGRA8888_t* )pBuffer, nBufSize / sizeof(BGRA8888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_RGB888:
|
|
WriteToBufferRGB( ( RGB888_t* )pBuffer, nBufSize / sizeof(RGB888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGR888:
|
|
WriteToBufferRGB( ( BGR888_t* )pBuffer, nBufSize / sizeof(BGR888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_BGRX8888:
|
|
WriteToBufferRGB( ( BGRX8888_t* )pBuffer, nBufSize / sizeof(BGRX8888_t), GetShortGammaTable( flGamma ) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UV88:
|
|
WriteToBufferUV( ( UV88_t* )pBuffer, nBufSize / sizeof(UV88_t) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UVWQ8888:
|
|
WriteToBufferUVWQ( ( UVWQ8888_t* )pBuffer, nBufSize / sizeof(UVWQ8888_t) );
|
|
break;
|
|
|
|
case IMAGE_FORMAT_UVLX8888:
|
|
WriteToBufferUVLX( ( UVLX8888_t* )pBuffer, nBufSize / sizeof(UVLX8888_t) );
|
|
break;
|
|
|
|
default:
|
|
Warning( "FloatBitMap_t::WriteToBuffer: Unsupported color format, skipping!\n" );
|
|
Assert( 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Loads from a PSD file
|
|
//-----------------------------------------------------------------------------
|
|
bool FloatBitMap_t::LoadFromPSD( const char *pFilename )
|
|
{
|
|
Bitmap_t bitmap;
|
|
CUtlStreamBuffer buf( pFilename, "GAME", CUtlBuffer::READ_ONLY );
|
|
if ( IsPSDFile( buf ) )
|
|
{
|
|
if ( !PSDReadFileRGBA8888( buf, bitmap ) )
|
|
return false;
|
|
|
|
if ( bitmap.Format() != IMAGE_FORMAT_RGBA8888 )
|
|
return false;
|
|
}
|
|
Init( bitmap.Width(), bitmap.Height() );
|
|
for ( int x = 0; x < bitmap.Width(); x++ )
|
|
{
|
|
for ( int y = 0; y < bitmap.Height(); y++ )
|
|
{
|
|
RGBA8888_t* pPixel = (RGBA8888_t*)bitmap.GetPixel( x, y );
|
|
Pixel( x, y, 0, 0 ) = pPixel->r / 255.0f;
|
|
Pixel( x, y, 0, 1 ) = pPixel->g / 255.0f;
|
|
Pixel( x, y, 0, 2 ) = pPixel->b / 255.0f;
|
|
Pixel( x, y, 0, 3 ) = pPixel->a / 255.0f;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Loads from a PFM file
|
|
//-----------------------------------------------------------------------------
|
|
#define PFM_MAX_XSIZE 2048
|
|
bool FloatBitMap_t::LoadFromPFM( const char* fname )
|
|
{
|
|
bool bSuccess = false;
|
|
FileHandle_t f = g_pFullFileSystem->Open(fname, "rb");
|
|
if ( !f )
|
|
return false;
|
|
|
|
if( ( GetChar( f ) == 'P' ) && ( GetChar( f ) == 'F' ) && ( GetChar( f ) == '\n' ) )
|
|
{
|
|
int nWidth = GetInt( f );
|
|
int nHeight = GetInt( f );
|
|
|
|
// eat crap until the next newline
|
|
while( GetChar( f ) != '\n' )
|
|
{
|
|
}
|
|
|
|
// printf("file %s w=%d h=%d\n",fname,Width,Height);
|
|
Init( nWidth, nHeight );
|
|
|
|
for( int y = nHeight - 1; y >= 0; y-- )
|
|
{
|
|
float linebuffer[PFM_MAX_XSIZE * 3];
|
|
g_pFullFileSystem->Read( linebuffer, 3 * nWidth * sizeof( float ), f );
|
|
for( int x = 0; x < nWidth; x++ )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
Pixel( x, y, 0, c ) = linebuffer[x * 3 + c];
|
|
}
|
|
}
|
|
}
|
|
bSuccess = true;
|
|
}
|
|
g_pFullFileSystem->Close( f ); // close file after reading
|
|
return bSuccess;
|
|
}
|
|
|
|
bool FloatBitMap_t::WritePFM( const char* fname )
|
|
{
|
|
FileHandle_t f = g_pFullFileSystem->Open(fname, "wb");
|
|
|
|
if ( f )
|
|
{
|
|
g_pFullFileSystem->FPrintf( f, "PF\n%d %d\n-1.000000\n", NumCols(), NumRows());
|
|
for( int y = NumRows() - 1; y >= 0; y-- )
|
|
{
|
|
float linebuffer[PFM_MAX_XSIZE * 3];
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
linebuffer[x * 3 + c]= Pixel( x, y, 0, c );
|
|
}
|
|
}
|
|
g_pFullFileSystem->Write( linebuffer, 3 * NumCols() * sizeof( float ), f );
|
|
}
|
|
g_pFullFileSystem->Close( f );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
float FloatBitMap_t::InterpolatedPixel( float x, float y, int comp ) const
|
|
{
|
|
int Top = ( int )floor( y );
|
|
float Yfrac = y - Top;
|
|
int Bot = MIN( NumRows() - 1, Top + 1 );
|
|
int Left = ( int )floor( x );
|
|
float Xfrac = x - Left;
|
|
int Right = MIN( NumCols() - 1, Left + 1 );
|
|
return
|
|
BiLinInterp( Xfrac, Yfrac,
|
|
Pixel( Left, Top, 0, comp ),
|
|
Pixel( Right, Top, 0, comp ),
|
|
Pixel( Left, Bot, 0, comp ),
|
|
Pixel( Right, Bot, 0, comp ) );
|
|
|
|
}
|
|
|
|
float FloatBitMap_t::InterpolatedPixel( float x, float y, float z, int comp ) const
|
|
{
|
|
int Top = ( int )floor( y );
|
|
float Yfrac = y - Top;
|
|
int Bot = MIN( NumRows() - 1, Top + 1 );
|
|
int Left = ( int )floor( x );
|
|
float Xfrac = x - Left;
|
|
int Right = MIN( NumCols() - 1, Left + 1 );
|
|
int Near = ( int )floor( z );
|
|
float Zfrac = z - Near;
|
|
int Far = MIN( NumSlices() - 1, Near + 1 );
|
|
return
|
|
TriLinInterp( Xfrac, Yfrac, Zfrac,
|
|
Pixel( Left, Top, Near, comp ),
|
|
Pixel( Right, Top, Near, comp ),
|
|
Pixel( Left, Bot, Near, comp ),
|
|
Pixel( Right, Bot, Near, comp ),
|
|
Pixel( Left, Top, Far, comp ),
|
|
Pixel( Right, Top, Far, comp ),
|
|
Pixel( Left, Bot, Far, comp ),
|
|
Pixel( Right, Bot, Far, comp ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Method to slam a particular channel to always be the same value
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::SetChannel( int comp, float flValue )
|
|
{
|
|
for ( int z = 0; z < NumSlices(); z++ )
|
|
{
|
|
for ( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
for ( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
Pixel( x, y, z, comp ) = flValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
// resize (with bilinear filter) truecolor bitmap in place
|
|
|
|
void FloatBitMap_t::ReSize( int NewWidth, int NewHeight )
|
|
{
|
|
float XRatio = ( float )NumCols() / ( float )NewWidth;
|
|
float YRatio = ( float )NumRows() / ( float )NewHeight;
|
|
float SourceX, SourceY, Xfrac, Yfrac;
|
|
int Top, Bot, Left, Right;
|
|
|
|
FloatBitMap_t newrgba( NewWidth, NewHeight );
|
|
|
|
SourceY = 0;
|
|
for( int y = 0; y < NewHeight; y++ )
|
|
{
|
|
Yfrac = SourceY - floor( SourceY );
|
|
Top = ( int )SourceY;
|
|
Bot = ( int )(SourceY + 1 );
|
|
if ( Bot >= NumRows() )
|
|
Bot = NumRows() - 1;
|
|
SourceX = 0;
|
|
for( int x = 0; x < NewWidth; x++ )
|
|
{
|
|
Xfrac = SourceX - floor( SourceX );
|
|
Left = ( int )SourceX;
|
|
Right = ( int )( SourceX + 1 );
|
|
if ( Right >= NumCols() )
|
|
Right = NumCols() - 1;
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
newrgba.Pixel( x, y, 0, c ) = BiLinInterp( Xfrac, Yfrac,
|
|
Pixel( Left, Top, 0, c ),
|
|
Pixel( Right, Top, 0, c ),
|
|
Pixel( Left, Bot, 0, c ),
|
|
Pixel( Right, Bot, 0, c ) );
|
|
}
|
|
SourceX += XRatio;
|
|
}
|
|
SourceY += YRatio;
|
|
}
|
|
MoveDataFrom( newrgba );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes the image be a sub-range of the current image
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::Crop( int x1, int y1, int z1, int nWidth, int nHeight, int nDepth )
|
|
{
|
|
int x2 = x1 + nWidth;
|
|
int y2 = y1 + nHeight;
|
|
int z2 = z1 + nDepth;
|
|
|
|
if ( ( x1 >= NumCols() || y1 >= NumRows() || z1 >= NumSlices() ) || ( x2 <= 0 || y2 <= 0 || z2 <= 0 ) )
|
|
{
|
|
Init( nWidth, nHeight, nDepth );
|
|
return;
|
|
}
|
|
|
|
x1 = clamp( x1, 0, NumCols() );
|
|
y1 = clamp( y1, 0, NumRows() );
|
|
z1 = clamp( z1, 0, NumSlices() );
|
|
x2 = clamp( x2, 0, NumCols() );
|
|
y2 = clamp( y2, 0, NumRows() );
|
|
z2 = clamp( z2, 0, NumSlices() );
|
|
nWidth = x2 - x1; nHeight = y2 - y1; nDepth = z2 - z1;
|
|
|
|
// Check for crops that don't require data movement
|
|
if ( NumSlices() <= 1 )
|
|
{
|
|
if ( nWidth == NumCols() )
|
|
{
|
|
m_nRows = nHeight;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( nWidth == NumCols() && nHeight == NumRows() )
|
|
{
|
|
m_nSlices = nDepth;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Generic data movement; works because data is stored in ascending
|
|
// order in memory in the same way as we're looping over the data
|
|
int ci[4];
|
|
int nAttr = ComputeValidAttributeList( ci );
|
|
for ( int z = 0; z < nDepth; ++z )
|
|
{
|
|
for ( int y = 0; y < nHeight; ++y )
|
|
{
|
|
for ( int x = 0; x < nWidth; ++x )
|
|
{
|
|
for ( int c = 0; c < nAttr; ++c )
|
|
{
|
|
Pixel( x, y, z, ci[c] ) = Pixel( x + x1, y + y1, z + z1, ci[c] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
struct TGAHeader_t
|
|
{
|
|
unsigned char id_length, colormap_type, image_type;
|
|
unsigned char colormap_index0, colormap_index1, colormap_length0, colormap_length1;
|
|
unsigned char colormap_size;
|
|
unsigned char x_origin0, x_origin1, y_origin0, y_origin1, width0, width1, height0, height1;
|
|
unsigned char pixel_size, attributes;
|
|
};
|
|
|
|
bool FloatBitMap_t::WriteTGAFile( const char* filename ) const
|
|
{
|
|
FileHandle_t f = g_pFullFileSystem->Open(filename, "wb");
|
|
if ( f )
|
|
{
|
|
TGAHeader_t myheader;
|
|
memset( & myheader, 0, sizeof( myheader ) );
|
|
myheader.image_type = 2;
|
|
myheader.pixel_size = 32;
|
|
myheader.width0 = NumCols() & 0xff;
|
|
myheader.width1 = ( NumCols() >> 8 );
|
|
myheader.height0 = NumRows() & 0xff;
|
|
myheader.height1 = ( NumRows() >> 8 );
|
|
myheader.attributes = 0x20;
|
|
g_pFullFileSystem->Write( & myheader, sizeof( myheader ), f );
|
|
// now, write the pixels
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
PixRGBAF fpix = PixelRGBAF( x, y, 0 );
|
|
PixRGBA8 pix8 = PixRGBAF_to_8( fpix );
|
|
|
|
g_pFullFileSystem->Write( & pix8.Blue, 1, f );
|
|
g_pFullFileSystem->Write( & pix8.Green, 1, f );
|
|
g_pFullFileSystem->Write( & pix8.Red, 1, f );
|
|
g_pFullFileSystem->Write( & pix8.Alpha, 1, f );
|
|
}
|
|
}
|
|
g_pFullFileSystem->Close( f ); // close file after reading
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FloatBitMap_t::FloatBitMap_t( const char* tgafilename )
|
|
{
|
|
// load from a tga or pfm or psd
|
|
if ( Q_stristr( tgafilename, ".psd") )
|
|
{
|
|
LoadFromPSD( tgafilename );
|
|
return;
|
|
}
|
|
if ( Q_stristr( tgafilename, ".pfm") )
|
|
{
|
|
LoadFromPFM( tgafilename );
|
|
return;
|
|
}
|
|
|
|
int width1, height1;
|
|
ImageFormat imageFormat1;
|
|
float gamma1;
|
|
|
|
if( !TGALoader::GetInfo( tgafilename, &width1, &height1, &imageFormat1, &gamma1 ) )
|
|
{
|
|
Warning( "FloatBitMap_t: Error opening %s\n", tgafilename );
|
|
Init( 1, 1 );
|
|
Pixel( 0, 0, 0, 0 ) = Pixel( 0, 0, 0, 3 ) = 1.0f;
|
|
Pixel( 0, 0, 0, 1 ) = Pixel( 0, 0, 0, 2 ) = 0.0f;
|
|
return;
|
|
}
|
|
|
|
Init( width1, height1 );
|
|
|
|
uint8 * pImage1Tmp =
|
|
new uint8 [ImageLoader::GetMemRequired( width1, height1, 1, imageFormat1, false )];
|
|
|
|
if( !TGALoader::Load( pImage1Tmp, tgafilename, width1, height1, imageFormat1, 2.2f, false ) )
|
|
{
|
|
Warning( "FloatBitMap_t: Error loading %s\n", tgafilename );
|
|
Init( 1, 1 );
|
|
Pixel( 0, 0, 0, 0 ) = Pixel( 0, 0, 0, 3 ) = 1.0f;
|
|
Pixel( 0, 0, 0, 1 ) = Pixel( 0, 0, 0, 2 ) = 0.0f;
|
|
delete[] pImage1Tmp;
|
|
return;
|
|
}
|
|
uint8 * pImage1 =
|
|
new uint8 [ImageLoader::GetMemRequired( width1, height1, 1, IMAGE_FORMAT_ABGR8888, false )];
|
|
|
|
ImageLoader::ConvertImageFormat( pImage1Tmp, imageFormat1, pImage1, IMAGE_FORMAT_ABGR8888, width1, height1, 0, 0 );
|
|
|
|
for( int y = 0; y < height1; y++ )
|
|
{
|
|
for( int x = 0; x < width1; x++ )
|
|
{
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
Pixel( x, y, 0, 3 - c ) = pImage1[c + 4 * ( x + ( y * width1 ) )]/ 255.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] pImage1;
|
|
delete[] pImage1Tmp;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using bilinear filtering
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::QuarterSize2D( FloatBitMap_t *pDest, int nStart, int nCount )
|
|
{
|
|
for( int y = nStart; y < nStart + nCount; y++ )
|
|
{
|
|
for( int x = 0; x < pDest->NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
pDest->Pixel( x, y, 0, c ) =
|
|
( ( Pixel( x * 2, y * 2, 0, c ) + Pixel( x * 2 + 1, y * 2, 0, c ) +
|
|
Pixel( x * 2, y * 2 + 1, 0, c ) + Pixel( x * 2 + 1, y * 2 + 1, 0, c ) ) / 4.0f );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using trilinear filtering
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::QuarterSize3D( FloatBitMap_t *pDest, int nStart, int nCount )
|
|
{
|
|
for( int z = nStart; z < nStart + nCount; z++ )
|
|
{
|
|
for( int y = 0; y < pDest->NumRows(); y++ )
|
|
{
|
|
for( int x = 0; x < pDest->NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
pDest->Pixel( x, y, z, c ) =
|
|
( ( Pixel( x * 2, y * 2, z * 2, c ) + Pixel( x * 2 + 1, y * 2, z * 2, c ) +
|
|
Pixel( x * 2, y * 2 + 1,z * 2, c ) + Pixel( x * 2 + 1, y * 2 + 1,z * 2, c ) +
|
|
Pixel( x * 2, y * 2, z * 2 + 1, c ) + Pixel( x * 2 + 1, y * 2, z * 2 + 1, c ) +
|
|
Pixel( x * 2, y * 2 + 1,z * 2 + 1, c ) + Pixel( x * 2 + 1, y * 2 + 1,z * 2 + 1, c ) ) / 8.0f );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FloatBitMap_t::QuarterSize( FloatBitMap_t *pBitmap )
|
|
{
|
|
// generate a new bitmap half on each axis
|
|
bool bIs2D = ( NumSlices() == 1 );
|
|
|
|
int sx = NumCols() / 2;
|
|
int sy = NumRows() / 2;
|
|
int sz = NumSlices() / 2;
|
|
sx = MAX( sx, 1 );
|
|
sy = MAX( sy, 1 );
|
|
sz = MAX( sz, 1 );
|
|
|
|
pBitmap->Init( sx, sy, sz );
|
|
|
|
if ( bIs2D )
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, pBitmap, 0, sy, 16, this, &FloatBitMap_t::QuarterSize2D );
|
|
}
|
|
else
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, pBitmap, 0, sz, 8, this, &FloatBitMap_t::QuarterSize3D );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using bilinear filtering
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::QuarterSizeBlocky2D( FloatBitMap_t *pDest, int nStart, int nCount )
|
|
{
|
|
for( int y = nStart; y < nStart + nCount; y++ )
|
|
{
|
|
for( int x = 0; x < pDest->NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
pDest->Pixel( x, y, 0, c ) = Pixel( x * 2, y * 2, 0, c );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using trilinear filtering
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::QuarterSizeBlocky3D( FloatBitMap_t *pDest, int nStart, int nCount )
|
|
{
|
|
for( int z = nStart; z < nStart + nCount; z++ )
|
|
{
|
|
for( int y = 0; y < pDest->NumRows(); y++ )
|
|
{
|
|
for( int x = 0; x < pDest->NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 4; c++ )
|
|
{
|
|
pDest->Pixel( x, y, z, c ) = Pixel( x * 2, y * 2, z * 2, c );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using point sampling
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::QuarterSizeBlocky( FloatBitMap_t *pBitmap )
|
|
{
|
|
// generate a new bitmap half on each axis
|
|
int sx = NumCols() / 2;
|
|
int sy = NumRows() / 2;
|
|
int sz = NumSlices() / 2;
|
|
sx = MAX( sx, 1 );
|
|
sy = MAX( sy, 1 );
|
|
sz = MAX( sz, 1 );
|
|
|
|
pBitmap->Init( sx, sy, sz );
|
|
|
|
if ( NumSlices() == 1 )
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, pBitmap, 0, sy, 128, this, &FloatBitMap_t::QuarterSizeBlocky2D );
|
|
}
|
|
else
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, pBitmap, 0, sz, 32, this, &FloatBitMap_t::QuarterSizeBlocky3D );
|
|
}
|
|
}
|
|
|
|
|
|
enum KernelType_t
|
|
{
|
|
KERNEL_DEFAULT = 0,
|
|
KERNEL_ALPHATEST,
|
|
};
|
|
|
|
struct FloatBitmapResampleInfo_t
|
|
{
|
|
FloatBitMap_t *m_pSrcBitmap;
|
|
FloatBitMap_t *m_pDestBitmap;
|
|
const KernelInfo_t *m_pKernel;
|
|
float *m_pAlphaResult;
|
|
int m_nFlags;
|
|
int m_nSrcWidth;
|
|
int m_nSrcHeight;
|
|
int m_nSrcDepth;
|
|
float m_flAlphaThreshhold;
|
|
float m_flAlphaHiFreqThreshhold;
|
|
int m_nWRatio;
|
|
int m_nHRatio;
|
|
int m_nDRatio;
|
|
};
|
|
|
|
typedef void (*ApplyKernelFunc_t)( FloatBitmapResampleInfo_t *pInfo, int nStart, int nCount );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Apply Kernel to an image
|
|
//-----------------------------------------------------------------------------
|
|
template< int type, bool bIsPowerOfTwo >
|
|
class CKernelWrapper
|
|
{
|
|
public:
|
|
static inline int ActualX( int x, FloatBitmapResampleInfo_t *pInfo )
|
|
{
|
|
if ( pInfo->m_nFlags & DOWNSAMPLE_CLAMPS )
|
|
return clamp( x, 0, pInfo->m_nSrcWidth - 1 );
|
|
|
|
// This works since pInfo->m_nSrcWidth is a power of two.
|
|
// Even for negative #s!
|
|
if ( bIsPowerOfTwo )
|
|
return x & (pInfo->m_nSrcWidth - 1);
|
|
return x % pInfo->m_nSrcWidth;
|
|
}
|
|
|
|
static inline int ActualY( int y, FloatBitmapResampleInfo_t *pInfo )
|
|
{
|
|
if ( pInfo->m_nFlags & DOWNSAMPLE_CLAMPT )
|
|
return clamp( y, 0, pInfo->m_nSrcHeight - 1 );
|
|
|
|
// This works since pInfo->m_nSrcHeight is a power of two.
|
|
// Even for negative #s!
|
|
if ( bIsPowerOfTwo )
|
|
return y & (pInfo->m_nSrcHeight - 1);
|
|
return y % pInfo->m_nSrcHeight;
|
|
}
|
|
|
|
static inline int ActualZ( int z, FloatBitmapResampleInfo_t *pInfo )
|
|
{
|
|
if ( pInfo->m_nFlags & DOWNSAMPLE_CLAMPU )
|
|
return clamp( z, 0, pInfo->m_nSrcDepth - 1 );
|
|
|
|
// This works since pInfo->m_nSrcDepth is a power of two.
|
|
// Even for negative #s!
|
|
if ( bIsPowerOfTwo )
|
|
return z & (pInfo->m_nSrcDepth - 1);
|
|
return z % pInfo->m_nSrcDepth;
|
|
}
|
|
|
|
static void ComputeWeightedAverageColor( FloatBitmapResampleInfo_t *pInfo,
|
|
int startX, int startY, int startZ, float *total )
|
|
{
|
|
total[0] = total[1] = total[2] = total[3] = 0.0f;
|
|
for ( int j = 0, srcZ = startZ; j < pInfo->m_pKernel->m_nDepth; ++j, ++srcZ )
|
|
{
|
|
int sz = ActualZ( srcZ, pInfo );
|
|
|
|
for ( int k = 0, srcY = startY; k < pInfo->m_pKernel->m_nHeight; ++k, ++srcY )
|
|
{
|
|
int sy = ActualY( srcY, pInfo );
|
|
|
|
int kernelIdx = pInfo->m_pKernel->m_nWidth * ( k + j * pInfo->m_pKernel->m_nHeight );
|
|
for ( int l = 0, srcX = startX; l < pInfo->m_pKernel->m_nWidth; ++l, ++srcX, ++kernelIdx )
|
|
{
|
|
int sx = ActualX( srcX, pInfo );
|
|
|
|
float flKernelFactor = pInfo->m_pKernel->m_pKernel[kernelIdx];
|
|
if ( flKernelFactor == 0.0f )
|
|
continue;
|
|
|
|
total[FBM_ATTR_RED] += flKernelFactor * pInfo->m_pSrcBitmap->Pixel( sx, sy, sz, FBM_ATTR_RED );
|
|
total[FBM_ATTR_GREEN] += flKernelFactor * pInfo->m_pSrcBitmap->Pixel( sx, sy, sz, FBM_ATTR_GREEN );
|
|
total[FBM_ATTR_BLUE] += flKernelFactor * pInfo->m_pSrcBitmap->Pixel( sx, sy, sz, FBM_ATTR_BLUE );
|
|
if ( type != KERNEL_ALPHATEST )
|
|
{
|
|
total[FBM_ATTR_ALPHA] += flKernelFactor * pInfo->m_pSrcBitmap->Pixel( sx, sy, sz, FBM_ATTR_ALPHA );
|
|
}
|
|
else
|
|
{
|
|
if ( pInfo->m_pSrcBitmap->Pixel( sx, sy, sz, FBM_ATTR_ALPHA ) > ( 192.0f / 255.0f ) )
|
|
{
|
|
total[FBM_ATTR_ALPHA] += flKernelFactor;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AddAlphaToAlphaResult( FloatBitmapResampleInfo_t *pInfo,
|
|
int startX, int startY, int startZ, float flAlpha, float *pAlphaResult )
|
|
{
|
|
for ( int j = 0, srcZ = startZ; j < pInfo->m_pKernel->m_nDepth; ++j, ++srcZ )
|
|
{
|
|
int sz = ActualZ( srcZ, pInfo );
|
|
sz *= pInfo->m_nSrcWidth * pInfo->m_nSrcHeight;
|
|
|
|
for ( int k = 0, srcY = startY; k < pInfo->m_pKernel->m_nHeight; ++k, ++srcY )
|
|
{
|
|
int sy = ActualY( srcY, pInfo );
|
|
sy *= pInfo->m_nSrcWidth;
|
|
|
|
int kernelIdx = k * pInfo->m_pKernel->m_nWidth + j * pInfo->m_pKernel->m_nWidth * pInfo->m_pKernel->m_nHeight;
|
|
for ( int l = 0, srcX = startX; l < pInfo->m_pKernel->m_nWidth; ++l, ++srcX, ++kernelIdx )
|
|
{
|
|
int sx = ActualX( srcX, pInfo );
|
|
int srcPixel = sz + sy + sx;
|
|
|
|
float flKernelFactor = pInfo->m_pKernel->m_pInvKernel[kernelIdx];
|
|
if ( flKernelFactor == 0.0f )
|
|
continue;
|
|
pAlphaResult[srcPixel] += flKernelFactor * flAlpha;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AdjustAlphaChannel( FloatBitmapResampleInfo_t *pInfo, float *pAlphaResult )
|
|
{
|
|
// Find the delta between the alpha + source image
|
|
int i, k;
|
|
int nDstPixel = 0;
|
|
for ( k = 0; k < pInfo->m_nSrcDepth; ++k )
|
|
{
|
|
for ( i = 0; i < pInfo->m_nSrcHeight; ++i )
|
|
{
|
|
for ( int j = 0; j < pInfo->m_nSrcWidth; ++j, ++nDstPixel )
|
|
{
|
|
pAlphaResult[nDstPixel] = fabs( pAlphaResult[nDstPixel] - pInfo->m_pSrcBitmap->Pixel( j, i, k, FBM_ATTR_ALPHA ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply the kernel to the image
|
|
int nInitialZ = ( pInfo->m_nDRatio > 1 ) ? (pInfo->m_nDRatio >> 1) - ((pInfo->m_nDRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
int nInitialY = ( pInfo->m_nHRatio > 1 ) ? (pInfo->m_nHRatio >> 1) - ((pInfo->m_nHRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
int nInitialX = ( pInfo->m_nWRatio > 1 ) ? (pInfo->m_nWRatio >> 1) - ((pInfo->m_nWRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
|
|
float flInvFactor = 1.0f;
|
|
if ( pInfo->m_nDRatio != 0 )
|
|
flInvFactor *= pInfo->m_nDRatio;
|
|
if ( pInfo->m_nHRatio != 0 )
|
|
flInvFactor *= pInfo->m_nHRatio;
|
|
if ( pInfo->m_nWRatio != 0 )
|
|
flInvFactor *= pInfo->m_nWRatio;
|
|
flInvFactor = 1.0f / flInvFactor;
|
|
|
|
for ( int h = 0; h < pInfo->m_pDestBitmap->NumSlices(); ++h )
|
|
{
|
|
int startZ = pInfo->m_nDRatio * h + nInitialZ;
|
|
for ( i = 0; i < pInfo->m_pDestBitmap->NumRows(); ++i )
|
|
{
|
|
int startY = pInfo->m_nHRatio * i + nInitialY;
|
|
for ( int j = 0; j < pInfo->m_pDestBitmap->NumCols(); ++j )
|
|
{
|
|
if ( pInfo->m_pDestBitmap->Pixel( j, i, h, FBM_ATTR_ALPHA ) == 1.0f )
|
|
continue;
|
|
|
|
int startX = pInfo->m_nWRatio * j + nInitialX;
|
|
float flAlphaDelta = 0.0f;
|
|
|
|
for ( int m = 0, srcZ = startZ; m < pInfo->m_nDRatio; ++m, ++srcZ )
|
|
{
|
|
int sz = ActualZ( srcZ, pInfo );
|
|
sz *= pInfo->m_nSrcWidth * pInfo->m_nSrcHeight;
|
|
|
|
for ( int k = 0, srcY = startY; k < pInfo->m_nHRatio; ++k, ++srcY )
|
|
{
|
|
int sy = ActualY( srcY, pInfo );
|
|
sy *= pInfo->m_nSrcWidth;
|
|
|
|
for ( int l = 0, srcX = startX; l < pInfo->m_nWRatio; ++l, ++srcX )
|
|
{
|
|
// HACK: This temp variable fixes an internal compiler error in vs2005
|
|
int temp = srcX;
|
|
int sx = ActualX( temp, pInfo );
|
|
|
|
int srcPixel = sz + sy + sx;
|
|
flAlphaDelta += pAlphaResult[srcPixel];
|
|
}
|
|
}
|
|
}
|
|
|
|
flAlphaDelta *= flInvFactor;
|
|
if ( flAlphaDelta > pInfo->m_flAlphaHiFreqThreshhold )
|
|
{
|
|
pInfo->m_pDestBitmap->Pixel( j, i, h, FBM_ATTR_ALPHA ) = 1.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ApplyKernel( FloatBitmapResampleInfo_t *pInfo, int nStart, int nCount )
|
|
{
|
|
// Apply the kernel to the image
|
|
int nInitialZ = ( pInfo->m_nDRatio > 1 ) ? (pInfo->m_nDRatio >> 1) - ((pInfo->m_nDRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
int nInitialY = ( pInfo->m_nHRatio > 1 ) ? (pInfo->m_nHRatio >> 1) - ((pInfo->m_nHRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
int nInitialX = ( pInfo->m_nWRatio > 1 ) ? (pInfo->m_nWRatio >> 1) - ((pInfo->m_nWRatio * pInfo->m_pKernel->m_nDiameter) >> 1) : 0;
|
|
|
|
int dw = pInfo->m_pDestBitmap->NumCols();
|
|
int dh = pInfo->m_pDestBitmap->NumRows();
|
|
int dd = pInfo->m_pDestBitmap->NumSlices();
|
|
|
|
int sk, ek, si, ei;
|
|
if ( dd == 1 )
|
|
{
|
|
sk = 0; ek = dd; si = nStart; ei = nStart + nCount;
|
|
}
|
|
else
|
|
{
|
|
sk = nStart; ek = nStart + nCount; si = 0; ei = dh;
|
|
}
|
|
|
|
for ( int k = sk; k < ek; ++k )
|
|
{
|
|
int startZ = pInfo->m_nDRatio * k + nInitialZ;
|
|
for ( int i = si; i < ei; ++i )
|
|
{
|
|
int startY = pInfo->m_nHRatio * i + nInitialY;
|
|
for ( int j = 0; j < dw; ++j )
|
|
{
|
|
int startX = pInfo->m_nWRatio * j + nInitialX;
|
|
|
|
float total[4];
|
|
ComputeWeightedAverageColor( pInfo, startX, startY, startZ, total );
|
|
|
|
// NOTE: Can't use a table here, we lose too many bits
|
|
if( type != KERNEL_ALPHATEST )
|
|
{
|
|
for ( int ch = 0; ch < 4; ++ ch )
|
|
{
|
|
pInfo->m_pDestBitmap->Pixel( j, i, k, ch ) = clamp( total[ch], 0.0f, 1.0f );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If there's more than 40% coverage, then keep the pixel (renormalize the color based on coverage)
|
|
float flAlpha = ( total[3] >= pInfo->m_flAlphaThreshhold ) ? 1.0f : 0.0f;
|
|
|
|
for ( int ch = 0; ch < 3; ++ ch )
|
|
{
|
|
pInfo->m_pDestBitmap->Pixel( j, i, k, ch ) = clamp( total[ch], 0.0f, 1.0f );
|
|
}
|
|
pInfo->m_pDestBitmap->Pixel( j, i, k, FBM_ATTR_ALPHA ) = clamp( flAlpha, 0.0f, 1.0f );
|
|
|
|
AddAlphaToAlphaResult( pInfo, startX, startY, startZ, flAlpha, pInfo->m_pAlphaResult );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( type == KERNEL_ALPHATEST )
|
|
{
|
|
AdjustAlphaChannel( pInfo, pInfo->m_pAlphaResult );
|
|
}
|
|
}
|
|
};
|
|
|
|
typedef CKernelWrapper< KERNEL_DEFAULT, false > ApplyKernelDefault_t;
|
|
typedef CKernelWrapper< KERNEL_ALPHATEST, false > ApplyKernelAlphatest_t;
|
|
typedef CKernelWrapper< KERNEL_DEFAULT, true > ApplyKernelDefaultPow2_t;
|
|
typedef CKernelWrapper< KERNEL_ALPHATEST, true > ApplyKernelAlphatestPow2_t;
|
|
|
|
static ApplyKernelFunc_t g_KernelFunc[] =
|
|
{
|
|
ApplyKernelDefault_t::ApplyKernel,
|
|
ApplyKernelAlphatest_t::ApplyKernel,
|
|
};
|
|
|
|
static ApplyKernelFunc_t g_KernelFuncPow2[] =
|
|
{
|
|
ApplyKernelDefaultPow2_t::ApplyKernel,
|
|
ApplyKernelAlphatestPow2_t::ApplyKernel,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Downsample using specified kernel (NOTE: Dest bitmap needs to have been initialized w/ final size)
|
|
//-----------------------------------------------------------------------------
|
|
void FloatBitMap_t::DownsampleNiceFiltered( const DownsampleInfo_t& downsampleInfo, FloatBitMap_t *pDestBitmap )
|
|
{
|
|
FloatBitmapResampleInfo_t info;
|
|
|
|
info.m_nFlags = downsampleInfo.m_nFlags;
|
|
info.m_pSrcBitmap = this;
|
|
info.m_pDestBitmap = pDestBitmap;
|
|
info.m_nWRatio = NumCols() / pDestBitmap->NumCols();
|
|
info.m_nHRatio = NumRows() / pDestBitmap->NumRows();
|
|
info.m_nDRatio = NumSlices() / pDestBitmap->NumSlices();
|
|
info.m_nSrcWidth = NumCols();
|
|
info.m_nSrcHeight = NumRows();
|
|
info.m_nSrcDepth = NumSlices();
|
|
info.m_flAlphaThreshhold = ( downsampleInfo.m_flAlphaThreshhold >= 0.0f ) ? downsampleInfo.m_flAlphaThreshhold : 0.4f;
|
|
info.m_flAlphaHiFreqThreshhold = ( downsampleInfo.m_flAlphaHiFreqThreshhold >= 0.0f ) ? downsampleInfo.m_flAlphaHiFreqThreshhold : 0.4f;
|
|
info.m_pAlphaResult = NULL;
|
|
|
|
KernelInfo_t kernel;
|
|
ImageLoader::ComputeNiceFilterKernel( info.m_nWRatio, info.m_nHRatio, info.m_nDRatio, &kernel );
|
|
info.m_pKernel = &kernel;
|
|
|
|
bool bIsPowerOfTwo = IsPowerOfTwo( info.m_nSrcWidth ) && IsPowerOfTwo( info.m_nSrcHeight ) && IsPowerOfTwo( info.m_nSrcDepth );
|
|
|
|
KernelType_t type;
|
|
if ( downsampleInfo.m_nFlags & DOWNSAMPLE_ALPHATEST )
|
|
{
|
|
int nSize = info.m_nSrcHeight * info.m_nSrcWidth * info.m_nSrcDepth * sizeof(float);
|
|
info.m_pAlphaResult = (float*)malloc( nSize );
|
|
memset( info.m_pAlphaResult, 0, nSize );
|
|
type = KERNEL_ALPHATEST;
|
|
}
|
|
else
|
|
{
|
|
type = KERNEL_DEFAULT;
|
|
}
|
|
|
|
int nCount, nChunkSize;
|
|
if ( info.m_nDRatio == 1 )
|
|
{
|
|
nCount = pDestBitmap->NumRows();
|
|
nChunkSize = 16;
|
|
}
|
|
else
|
|
{
|
|
nCount = pDestBitmap->NumSlices();
|
|
nChunkSize = 8;
|
|
}
|
|
|
|
if ( bIsPowerOfTwo )
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, &info, 0, nCount, nChunkSize, g_KernelFuncPow2[type] );
|
|
}
|
|
else
|
|
{
|
|
ParallelLoopProcessChunks( sm_pFBMThreadPool, &info, 0, nCount, nChunkSize, g_KernelFunc[type] );
|
|
}
|
|
|
|
if ( info.m_pAlphaResult )
|
|
{
|
|
free( info.m_pAlphaResult );
|
|
}
|
|
ImageLoader::CleanupNiceFilterKernel( &kernel );
|
|
}
|
|
|
|
|
|
Vector FloatBitMap_t::AverageColor( void )
|
|
{
|
|
Vector ret( 0, 0, 0 );
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
ret[c]+= Pixel( x, y, 0, c );
|
|
ret *= 1.0 / ( NumCols() * NumRows() );
|
|
return ret;
|
|
}
|
|
|
|
float FloatBitMap_t::BrightestColor( void )
|
|
{
|
|
float ret = 0.0;
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
Vector v( Pixel( x, y, 0, 0 ), Pixel( x, y, 0, 1 ), Pixel( x, y, 0, 2 ) );
|
|
ret = MAX( ret, v.Length() );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
template < class T > static inline void SWAP( T & a, T & b )
|
|
{
|
|
T temp = a;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
|
|
void FloatBitMap_t::RaiseToPower( float power )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x, y, 0, c ) = pow( ( float )MAX( 0.0, Pixel( x, y, 0, c ) ), ( float )power );
|
|
|
|
}
|
|
|
|
void FloatBitMap_t::Logize( void )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x, y, 0, c ) = log( 1.0 + Pixel( x, y, 0, c ) );
|
|
|
|
}
|
|
|
|
void FloatBitMap_t::UnLogize( void )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x, y, 0, c ) = exp( Pixel( x, y, 0, c ) ) - 1;
|
|
}
|
|
|
|
|
|
void FloatBitMap_t::Clear( float r, float g, float b, float a )
|
|
{
|
|
for ( int z = 0; z < NumSlices(); ++z )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
Pixel( x, y, z, 0 ) = r;
|
|
Pixel( x, y, z, 1 ) = g;
|
|
Pixel( x, y, z, 2 ) = b;
|
|
Pixel( x, y, z, 3 ) = a;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FloatBitMap_t::ScaleRGB( float scale_factor )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x, y, 0, c ) *= scale_factor;
|
|
}
|
|
|
|
static int dx[4]={0, - 1, 1, 0};
|
|
static int dy[4]={- 1, 0, 0, 1};
|
|
|
|
#define NDELTAS 4
|
|
|
|
void FloatBitMap_t::SmartPaste( const FloatBitMap_t & b, int xofs, int yofs, uint32 Flags )
|
|
{
|
|
// now, need to make Difference map
|
|
FloatBitMap_t DiffMap0( this );
|
|
FloatBitMap_t DiffMap1( this );
|
|
FloatBitMap_t DiffMap2( this );
|
|
FloatBitMap_t DiffMap3( this );
|
|
FloatBitMap_t * deltas[4]={& DiffMap0, & DiffMap1, & DiffMap2, & DiffMap3};
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
{
|
|
int x1 = x + dx[i];
|
|
int y1 = y + dy[i];
|
|
x1 = MAX( 0, x1 );
|
|
x1 = MIN( NumCols() - 1, x1 );
|
|
y1 = MAX( 0, y1 );
|
|
y1 = MIN( NumRows() - 1, y1 );
|
|
float dx1 = Pixel( x, y, 0, c ) - Pixel( x1, y1, 0, c );
|
|
deltas[i]-> Pixel( x, y, 0, c ) = dx1;
|
|
}
|
|
}
|
|
for( int x = 1; x < b.NumCols() - 1; x++ )
|
|
for( int y = 1; y < b.NumRows() - 1; y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
{
|
|
float diff = b.Pixel( x, y, 0, c ) - b.Pixel( x + dx[i], y + dy[i], 0, c );
|
|
deltas[i]-> Pixel( x + xofs, y + yofs, 0, c ) = diff;
|
|
if ( Flags & SPFLAGS_MAXGRADIENT )
|
|
{
|
|
float dx1 = Pixel( x + xofs, y + yofs, 0, c ) - Pixel( x + dx[i]+ xofs, y + dy[i]+ yofs, 0, c );
|
|
if ( fabs( dx1 ) > fabs( diff ) )
|
|
deltas[i]-> Pixel( x + xofs, y + yofs, 0, c ) = dx1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// now, calculate modifiability
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
float modify = 0;
|
|
if (
|
|
( x > xofs + 1 ) && ( x <= xofs + b.NumCols() - 2 ) &&
|
|
( y > yofs + 1 ) && ( y <= yofs + b.NumRows() - 2 ) )
|
|
modify = 1;
|
|
Alpha( x, y, 0 ) = modify;
|
|
}
|
|
|
|
// // now, force a fex pixels in center to be constant
|
|
// int midx=xofs+b.Width/2;
|
|
// int midy=yofs+b.Height/2;
|
|
// for(x=midx-10;x<midx+10;x++)
|
|
// for(int y=midy-10;y<midy+10;y++)
|
|
// {
|
|
// Alpha(x,y)=0;
|
|
// for(int c=0;c<3;c++)
|
|
// Pixel(x,y,c)=b.Pixel(x-xofs,y-yofs,c);
|
|
// }
|
|
Poisson( deltas, 6000, Flags );
|
|
}
|
|
|
|
void FloatBitMap_t::ScaleGradients( void )
|
|
{
|
|
// now, need to make Difference map
|
|
FloatBitMap_t DiffMap0( this );
|
|
FloatBitMap_t DiffMap1( this );
|
|
FloatBitMap_t DiffMap2( this );
|
|
FloatBitMap_t DiffMap3( this );
|
|
FloatBitMap_t * deltas[4]={& DiffMap0, & DiffMap1, & DiffMap2, & DiffMap3};
|
|
double gsum = 0.0;
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
{
|
|
int x1 = x + dx[i];
|
|
int y1 = y + dy[i];
|
|
x1 = MAX( 0, x1 );
|
|
x1 = MIN( NumCols() - 1, x1 );
|
|
y1 = MAX( 0, y1 );
|
|
y1 = MIN( NumRows() - 1, y1 );
|
|
float dx1 = Pixel( x, y, 0, c ) - Pixel( x1, y1, 0, c );
|
|
deltas[i]-> Pixel( x, y, 0, c ) = dx1;
|
|
gsum += fabs( dx1 );
|
|
}
|
|
}
|
|
// now, reduce gradient changes
|
|
// float gavg=gsum/(NumCols()*NumRows());
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
{
|
|
float norml = 1.1 * deltas[i]-> Pixel( x, y, 0, c );
|
|
// if (norml<0.0)
|
|
// norml=-pow(-norml,1.2);
|
|
// else
|
|
// norml=pow(norml,1.2);
|
|
deltas[i]-> Pixel( x, y, 0, c ) = norml;
|
|
}
|
|
}
|
|
|
|
// now, calculate modifiability
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
float modify = 0;
|
|
if (
|
|
( x > 0 ) && ( x < NumCols() - 1 ) &&
|
|
( y ) && ( y < NumRows() - 1 ) )
|
|
{
|
|
modify = 1;
|
|
Alpha( x, y, 0 ) = modify;
|
|
}
|
|
}
|
|
|
|
Poisson( deltas, 2200, 0 );
|
|
}
|
|
|
|
|
|
|
|
static inline float FLerp( float f1, float f2, float t )
|
|
{
|
|
return f1 + ( f2 - f1 ) * t;
|
|
}
|
|
|
|
void FloatBitMap_t::MakeTileable( void )
|
|
{
|
|
FloatBitMap_t rslta( this );
|
|
// now, need to make Difference map
|
|
FloatBitMap_t DiffMapX( this );
|
|
FloatBitMap_t DiffMapY( this );
|
|
// set each pixel=avg-pixel
|
|
FloatBitMap_t * cursrc =& rslta;
|
|
for( int x = 1; x < NumCols() - 1; x++ )
|
|
for( int y = 1; y < NumRows() - 1; y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
DiffMapX.Pixel( x, y, 0, c ) = Pixel( x, y, 0, c ) - Pixel( x + 1, y, 0, c );
|
|
DiffMapY.Pixel( x, y, 0, c ) = Pixel( x, y, 0, c ) - Pixel( x, y + 1, 0, c );
|
|
}
|
|
// initialize edge conditions
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
float a = 0.5 * ( Pixel( x, NumRows() - 1, 0, c ) += Pixel( x, 0, 0, c ) );
|
|
rslta.Pixel( x, NumRows() - 1, 0, c ) = a;
|
|
rslta.Pixel( x, 0, 0, c ) = a;
|
|
}
|
|
}
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
float a = 0.5 * ( Pixel( NumCols() - 1, y, 0, c ) + Pixel( 0, y, 0, c ) );
|
|
rslta.Pixel( NumCols() - 1, y, 0, c ) = a;
|
|
rslta.Pixel( 0, y, 0, c ) = a;
|
|
}
|
|
}
|
|
FloatBitMap_t rsltb( & rslta );
|
|
FloatBitMap_t * curdst =& rsltb;
|
|
|
|
// now, ready to iterate
|
|
for( int pass = 0; pass < 10; pass++ )
|
|
{
|
|
float error = 0.0;
|
|
for( int x = 1; x < NumCols() - 1; x++ )
|
|
for( int y = 1; y < NumRows() - 1; y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
float desiredx = DiffMapX.Pixel( x, y, 0, c ) + cursrc->Pixel( x + 1, y, 0, c );
|
|
float desiredy = DiffMapY.Pixel( x, y, 0, c ) + cursrc->Pixel( x, y + 1, 0, c );
|
|
float desired = 0.5 * ( desiredy + desiredx );
|
|
curdst->Pixel( x, y, 0, c ) = FLerp( cursrc->Pixel( x, y, 0, c ), desired, 0.5 );
|
|
error += SQ( desired - cursrc->Pixel( x, y, 0, c ) );
|
|
}
|
|
SWAP( cursrc, curdst );
|
|
}
|
|
// paste result
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x, y, 0, c ) = curdst->Pixel( x, y, 0, c );
|
|
}
|
|
|
|
|
|
void FloatBitMap_t::GetAlphaBounds( int & minx, int & miny, int & maxx, int & maxy )
|
|
{
|
|
for( minx = 0; minx < NumCols(); minx++ )
|
|
{
|
|
int y;
|
|
for( y = 0; y < NumRows(); y++ )
|
|
if ( Alpha( minx, y, 0 ) )
|
|
break;
|
|
if ( y != NumRows() )
|
|
break;
|
|
}
|
|
for( maxx = NumCols() - 1; maxx >= 0; maxx-- )
|
|
{
|
|
int y;
|
|
for( y = 0; y < NumRows(); y++ )
|
|
if ( Alpha( maxx, y, 0 ) )
|
|
break;
|
|
if ( y != NumRows() )
|
|
break;
|
|
}
|
|
for( miny = 0; minx < NumRows(); miny++ )
|
|
{
|
|
int x;
|
|
for( x = minx; x <= maxx; x++ )
|
|
if ( Alpha( x, miny, 0 ) )
|
|
break;
|
|
if ( x < maxx )
|
|
break;
|
|
}
|
|
for( maxy = NumRows() - 1; maxy >= 0; maxy-- )
|
|
{
|
|
int x;
|
|
for( x = minx; x <= maxx; x++ )
|
|
if ( Alpha( x, maxy, 0 ) )
|
|
break;
|
|
if ( x < maxx )
|
|
break;
|
|
}
|
|
}
|
|
|
|
void FloatBitMap_t::Poisson( FloatBitMap_t * deltas[4],
|
|
int n_iters,
|
|
uint32 flags // SPF_xxx
|
|
)
|
|
{
|
|
int minx, miny, maxx, maxy;
|
|
GetAlphaBounds( minx, miny, maxx, maxy );
|
|
minx = MAX( 1, minx );
|
|
miny = MAX( 1, miny );
|
|
maxx = MIN( NumCols() - 2, maxx );
|
|
maxy = MIN( NumRows() - 2, maxy );
|
|
if ( ( ( maxx - minx ) > 25 ) && ( maxy - miny ) > 25 )
|
|
{
|
|
// perform at low resolution
|
|
FloatBitMap_t * lowdeltas[NDELTAS];
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
{
|
|
lowdeltas[i] = new FloatBitMap_t;
|
|
deltas[i]->QuarterSize( lowdeltas[i] );
|
|
}
|
|
FloatBitMap_t * tmp = new FloatBitMap_t;
|
|
QuarterSize( tmp );
|
|
tmp->Poisson( lowdeltas, n_iters * 4, flags );
|
|
// now, propagate results from tmp to us
|
|
for( int x = 0; x < tmp->NumCols(); x++ )
|
|
for( int y = 0; y < tmp->NumRows(); y++ )
|
|
for( int xi = 0; xi < 2; xi++ )
|
|
for( int yi = 0; yi < 2; yi++ )
|
|
if ( Alpha( x * 2 + xi, y * 2 + yi, 0 ) )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
Pixel( x * 2 + xi, y * 2 + yi, 0, c ) =
|
|
FLerp( Pixel( x * 2 + xi, y * 2 + yi, 0, c ), tmp->Pixel( x, y, 0, c ), Alpha( x * 2 + xi, y * 2 + yi, 0 ) );
|
|
}
|
|
char fname[80];
|
|
sprintf(fname,"sub%dx%d.tga",tmp->NumCols(),tmp->NumRows());
|
|
tmp->WriteTGAFile( fname );
|
|
sprintf(fname,"submrg%dx%d.tga",tmp->NumCols(),tmp->NumRows());
|
|
WriteTGAFile( fname );
|
|
delete tmp;
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
delete lowdeltas[i];
|
|
}
|
|
FloatBitMap_t work1( this );
|
|
FloatBitMap_t work2( this );
|
|
FloatBitMap_t * curdst =& work1;
|
|
FloatBitMap_t * cursrc =& work2;
|
|
// now, ready to iterate
|
|
while( n_iters-- )
|
|
{
|
|
float error = 0.0;
|
|
for( int x = minx; x <= maxx; x++ )
|
|
{
|
|
for( int y = miny; y <= maxy; y++ )
|
|
{
|
|
if ( Alpha( x, y, 0 ) )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
float desired = 0.0;
|
|
for( int i = 0; i < NDELTAS; i++ )
|
|
desired += deltas[i]-> Pixel( x, y, 0, c ) + cursrc->Pixel( x + dx[i], y + dy[i], 0, c );
|
|
desired *= ( 1.0 / NDELTAS );
|
|
// desired=FLerp(Pixel(x,y,c),desired,Alpha(x,y));
|
|
curdst->Pixel( x, y, 0, c ) = FLerp( cursrc->Pixel( x, y, 0, c ), desired, 0.5 );
|
|
error += SQ( desired - cursrc->Pixel( x, y, 0, c ) );
|
|
}
|
|
}
|
|
SWAP( cursrc, curdst );
|
|
}
|
|
}
|
|
}
|
|
// paste result
|
|
for( int x = 0; x < NumCols(); x++ )
|
|
{
|
|
for( int y = 0; y < NumRows(); y++ )
|
|
{
|
|
for( int c = 0; c < 3; c++ )
|
|
{
|
|
Pixel( x, y, 0, c ) = curdst->Pixel( x, y, 0, c );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|