bool
ImageBufAlgo::crop (ImageBuf &dst, const ImageBuf &src,
ROI roi, int nthreads)
{
dst.clear ();
roi.chend = std::min (roi.chend, src.nchannels());
IBAprep (roi, &dst, &src);
OIIO_DISPATCH_TYPES2 ("crop", crop_, dst.spec().format, src.spec().format,
dst, src, roi, nthreads);
return false;
}
void
SMTool::imageToSMT( SMT *smt, ImageBuf *sourceBuf )
{
using namespace std::chrono;
if( verbose )
cout << "INFO: Converting image to tiles and saving to smt" << endl;
ImageSpec sourceSpec = sourceBuf->spec();
unsigned int tileRes = smt->getTileSize();
ImageBuf tileBuf;
ImageSpec tileSpec( tileRes, tileRes, 4, TypeDesc::UINT8 );
ROI roi( 0, 1, 0, 1, 0, 1, 0, 4 );
ImageSpec mapSpec(
sourceSpec.width / tileSpec.width,
sourceSpec.height / tileSpec.height,
1,
TypeDesc::UINT );
ImageBuf mapBuf( "tilemap", mapSpec );
// Loop vars
unsigned int currentTile;
// Comparison vars
bool match;
unsigned int i;
string hash;
vector<string> hashTable;
TileBufListEntry *listEntry;
deque<TileBufListEntry *> tileList;
if( verbose ){
cout << "\tSource: " << sourceSpec.width << "x" << sourceSpec.height << endl;
cout << "\ttileRes: " << tileSpec.width << "x" << tileSpec.height << endl;
cout << "\ttilemap: " << mapSpec.width << "x" << mapSpec.height << endl;
cout << "\tmaxTiles: " << mapSpec.image_pixels() << endl;
cout << " Processing tiles:\n";
}
for( ImageBuf::Iterator<unsigned int, unsigned int> it(mapBuf); ! it.done(); ++it ){
currentTile = it.y() * mapSpec.width + it.x();
// define the cropping region.
roi.xbegin = it.x() * tileSpec.width;
roi.xend = it.x() * tileSpec.width + tileSpec.width;
roi.ybegin = it.y() * tileSpec.height;
roi.yend = it.y() * tileSpec.height + tileSpec.height;
// crop out tile.
ImageBufAlgo::cut( tileBuf, *sourceBuf, roi );
#ifdef DEBUG_IMG
tileBuf.save("SMTool::imageToSMT_tileBuf_" + to_string( currentTile + 1 ) + ".tif", "tif");
#endif //DEBUG_IMG
// reset match variables
match = false;
i = smt->getNTiles();
// Optimisation
if( cnum == 0){
// only exact matches will be referenced.
hash = ImageBufAlgo::computePixelHashSHA1( tileBuf );
for( i = 0; i < hashTable.size(); ++i ){
if(! hashTable[ i ].compare( hash ) ){
match = true;
break;
}
}
if(! match ) hashTable.push_back( hash );
}
else {
//Comparison based on numerical differences of pixels
listEntry = new TileBufListEntry;
listEntry->image.copy( tileBuf );
listEntry->tileNum = smt->getNTiles();
ImageBufAlgo::CompareResults result;
for( auto it = tileList.begin(); it != tileList.end(); it++ ){
TileBufListEntry *listEntry2 = *it;
ImageBufAlgo::compare( tileBuf, listEntry2->image,
cpet, 1.0f, result);
// TODO give control on tweaking matching
if( (int)result.nfail < cnet ){
match = true;
i = listEntry2->tileNum;
delete listEntry;
break;
}
}
if(! match ){
tileList.push_back( listEntry );
if( (int)tileList.size() > cnum ){
delete tileList[ 0 ];
tileList.pop_front();
}
}
}
// write tile to file.
if(! match ) {
smt->append( &tileBuf );
}
tileBuf.clear();
// Write index to tilemap
it[0] = currentTile;
// progress report
cout << "\033[1A\033[2K\033[0G\t" << currentTile+1 << " of " << mapSpec.image_pixels() << ", %" << ((float)currentTile + 1) / mapSpec.image_pixels() * 100 << " complete." << endl;
}
hashTable.clear();
if( verbose ) cout << endl;
// Save tileindex
mapBuf.save( "tilemap.exr", "exr" );
}
bool
SMT::save()
{
// Make sure we have some source images before continuing
if( sourceFiles.size() == 0) {
if( !quiet )cout << "ERROR: No source images to convert" << endl;
return true;
}
// Build SMT Header //
//////////////////////
char filename[256];
sprintf(filename, "%s.smt", outPrefix.c_str());
if( verbose ) printf("\nINFO: Creating %s\n", filename );
fstream smt( filename, ios::binary | ios::out );
if( !smt.good() ) {
cout << "ERROR: fstream error." << endl;
return true;
}
SMTHeader header;
header.tileRes = tileRes;
header.tileType = tileType;
if( verbose ) {
cout << " Version: " << header.version << endl;
cout << " nTiles: n/a\n";
printf( " tileRes: (%i,%i)%i.\n", tileRes, tileRes, 4);
cout << " tileType: ";
if( tileType == DXT1 ) cout << "DXT1" << endl;
cout << " tileSize: " << tileSize << " bytes" << endl;
}
smt.write( (char *)&header, sizeof(SMTHeader) );
smt.close();
// setup size for index dimensions
int tcx = width * 16; // tile count x
int tcz = length * 16; // tile count z
unsigned int *indexPixels = new unsigned int[tcx * tcz];
// Load source image
if( verbose )cout << "INFO: Loading Source Image(s)\n";
ImageBuf *bigBuf = buildBig();
ImageSpec bigSpec = bigBuf->spec();
// Process decals
if( !decalFile.empty() ) {
if( verbose )cout << "INFO: Processing decals\n";
pasteDecals( bigBuf );
}
// Swizzle channels
if( verbose )cout << "INFO: Swizzling channels\n";
ImageBuf fixBuf;
int map[] = { 2, 1, 0, 3 };
ImageBufAlgo::channels( fixBuf, *bigBuf, 4, map );
bigBuf->copy( fixBuf );
fixBuf.clear();
// Process Tiles
if( verbose )cout << "INFO: Processing tiles\n";
// Time reporting vars
timeval t1, t2;
double elapsedTime;
deque<double> readings;
double averageTime = 0;
double intervalTime = 0;
// Loop vars
int totalTiles = tcx * tcz;
int currentTile;
// Tile Vars
ROI roi;
ImageSpec tileSpec(tileRes, tileRes, 4, TypeDesc::UINT8 );
// Comparison vars
bool match;
bool yee = false;
unsigned int i;
string hash;
vector<string> hashTable;
TileBufListEntry *listEntry;
deque<TileBufListEntry *> tileList;
// Open smt file for writing tiles
smt.open(filename, ios::binary | ios::out | ios::app );
// loop through tile columns
for ( int z = 0; z < tcz; z++) {
// loop through tile rows
for ( int x = 0; x < tcx; x++) {
currentTile = z * tcx + x + 1;
gettimeofday(&t1, NULL);
// pull a region of the big image to use as a tile.
roi.xbegin = x * tileRes;
roi.xend = x * tileRes + tileRes;
roi.ybegin = z * tileRes;
roi.yend = z * tileRes + tileRes;
roi.zbegin = 0;
roi.zend = 1;
roi.chbegin = 0;
roi.chend = 4;
ImageBuf tempBuf;
ImageBufAlgo::crop( tempBuf, *bigBuf, roi );
ImageBuf *tileBuf = new ImageBuf( filename, tileSpec, tempBuf.localpixels() );
// reset match variables
match = false;
i = nTiles;
if( cnum < 0) {
// no attempt at reducing tile sizes
i = nTiles;
} else if( cnum == 0) {
// only exact matches will be referenced.
hash = ImageBufAlgo::computePixelHashSHA1( *tileBuf );
for( i = 0; i < hashTable.size(); ++i ) {
if( !hashTable[i].compare( hash ) ) {
match = true;
break;
}
}
if( !match ) hashTable.push_back( hash );
} else if( !yee ) {
//Comparison based on numerical differences of pixels
listEntry = new TileBufListEntry;
listEntry->image.copy(*tileBuf);
listEntry->tileNum = nTiles;
ImageBufAlgo::CompareResults result;
deque< TileBufListEntry * >::iterator it;
for(it = tileList.begin(); it != tileList.end(); it++ ) {
TileBufListEntry *listEntry2 = *it;
ImageBufAlgo::compare( *tileBuf, listEntry2->image,
cpet, 1.0f, result);
//TODO give control on tweaking matching
if((int)result.nfail < cnet) {
match = true;
i = listEntry2->tileNum;
delete listEntry;
break;
}
}
if( !match ) {
tileList.push_back(listEntry);
if((int)tileList.size() > cnum) {
delete tileList[0];
tileList.pop_front();
}
}
} else {
//FIXME uncomment when OpenImageIO gets upgraded to v3
/* listEntry = new TileBufListEntry;
listEntry->image.copy(*tileBuf);
listEntry->tileNum = nTiles;
ImageBufAlgo::CompareResults result;
deque< TileBufListEntry * >::iterator it;
for(it = tileList.begin(); it != tileList.end(); it++ ) {
TileBufListEntry *listEntry2 = *it;
ImageBufAlgo::compare_yee( *tileBuf, listEntry2->image,
result, 1.0f, 1.0f );
if(result.nfail == 0) {
match = true;
i = listEntry2->tileNum;
break;
}
}
if( !match ) {
tileList.push_back(listEntry);
if((int)tileList.size() > 32) tileList.pop_front();
}*/
}
// write tile to file.
if( !match ) {
unsigned char *std = (unsigned char *)tileBuf->localpixels();
// process into dds
NVTTOutputHandler *nvttHandler = new NVTTOutputHandler(tileSize);
nvtt::InputOptions inputOptions;
inputOptions.setTextureLayout( nvtt::TextureType_2D, tileRes, tileRes );
inputOptions.setMipmapData( std, tileRes, tileRes );
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat(nvtt::Format_DXT1a);
nvtt::OutputOptions outputOptions;
outputOptions.setOutputHeader(false);
outputOptions.setOutputHandler( nvttHandler );
nvtt::Compressor compressor;
if( slow_dxt1 ) compressionOptions.setQuality(nvtt::Quality_Normal);
else compressionOptions.setQuality(nvtt::Quality_Fastest);
compressor.process(inputOptions, compressionOptions, outputOptions);
smt.write( nvttHandler->buffer, tileSize );
delete nvttHandler;
nTiles +=1;
}
delete tileBuf;
// Write index to tilemap
indexPixels[currentTile-1] = i;
gettimeofday(&t2, NULL);
// compute and print the elapsed time in millisec
elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0; // sec to ms
elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms
readings.push_back(elapsedTime);
if(readings.size() > 1000)readings.pop_front();
intervalTime += elapsedTime;
if( verbose && intervalTime > 1 ) {
for(unsigned int i = 0; i < readings.size(); ++i)
averageTime+= readings[i];
averageTime /= readings.size();
intervalTime = 0;
printf("\033[0G %i of %i %%%0.1f complete | %%%0.1f savings | %0.1fs remaining.",
currentTile, totalTiles,
(float)currentTile / totalTiles * 100,
(float)(1 - (float)nTiles / (float)currentTile) * 100,
averageTime * (totalTiles - currentTile) / 1000);
}
}
}
hashTable.clear();
if( verbose ) cout << endl;
smt.close();
// retroactively fix up the tile count.
smt.open(filename, ios::binary | ios::in | ios::out );
smt.seekp( 20);
smt.write( (char *)&nTiles, 4);
smt.close();
// Save tileindex
ImageOutput *imageOutput;
sprintf( filename, "%s_tilemap.exr", outPrefix.c_str() );
imageOutput = ImageOutput::create(filename);
if( !imageOutput ) {
delete [] indexPixels;
return true;
}
ImageSpec tilemapSpec( tcx, tcz, 1, TypeDesc::UINT);
imageOutput->open( filename, tilemapSpec );
imageOutput->write_image( TypeDesc::UINT, indexPixels );
imageOutput->close();
delete imageOutput;
delete [] indexPixels;
return false;
}
bool
SMF::saveGrass()
{
if( verbose )cout << "INFO: saveGrass\n";
SMFEHGrass *grassHeader = NULL;
for( unsigned int i = 0; i < extraHeaders.size(); ++i ) {
if( extraHeaders[ i ]->type == 1 )
grassHeader = reinterpret_cast<SMFEHGrass *>( extraHeaders[ i ] );
}
if( !grassHeader )return true;
ImageBuf *imageBuf = NULL;
ROI roi( 0, width * 16,
0, length * 16,
0, 1,
0, 1);
ImageSpec imageSpec(roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 );
if( is_smf(grassFile) ) {
// Load from SMF
SMF sourcesmf(grassFile);
imageBuf = sourcesmf.getGrass();
}
if( !imageBuf ) {
// Load image file
imageBuf = new ImageBuf( grassFile );
imageBuf->read( 0, 0, false, TypeDesc::UINT8 );
if( imageBuf->initialized() ) {
delete imageBuf;
imageBuf = NULL;
}
}
if( !imageBuf ) {
// Generate blank
imageBuf = new ImageBuf( "grass", imageSpec );
}
imageSpec = imageBuf->specmod();
ImageBuf fixBuf;
// Fix the number of channels
if( imageSpec.nchannels != roi.chend ) {
int map[] = {0};
ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map );
imageBuf->copy( fixBuf );
fixBuf.clear();
}
// Fix the Dimensions
if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) {
if( verbose )
printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i) Resampling.\n",
typeFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend);
ImageBufAlgo::resample(fixBuf, *imageBuf, false, roi);
imageBuf->copy( fixBuf );
fixBuf.clear();
}
unsigned char *pixels = (unsigned char *)imageBuf->localpixels();
char filename[256];
sprintf( filename, "%s.smf", outPrefix.c_str() );
if( verbose )printf( " Source: %s.\n", grassFile.c_str() );
fstream smf(filename, ios::binary | ios::in | ios::out);
smf.seekp(grassHeader->grassPtr);
smf.write( (char *)pixels, imageBuf->spec().image_bytes() );
smf.close();
delete imageBuf;
if( is_smf( grassFile ) ) delete [] pixels;
return false;
}
bool
SMF::saveTilemap()
{
if( verbose )cout << "INFO: saveTilemap\n";
char filename[256];
sprintf( filename, "%s.smf", outPrefix.c_str() );
fstream smf(filename, ios::binary | ios::in | ios::out);
smf.seekp(tilesPtr);
// Tiles Header
int nTileFiles = smtList.size();
smf.write( (char *)&nTileFiles, 4);
smf.write( (char *)&nTiles, 4);
if(verbose)printf( " %i tiles referenced in %i files\n", nTiles, nTileFiles );
// SMT Names
for(unsigned int i = 0; i < smtList.size(); ++i) {
if( verbose )printf( "\t%i %s\n", smtTiles[i], smtList[i].c_str() );
smf.write( (char *)&smtTiles[i], 4);
smf.write( smtList[i].c_str(), smtList[i].size() +1 );
}
// Dimensions of displacement map.
ImageBuf *imageBuf = NULL;
ROI roi( 0, width * 16, // xbegin, xend
0, length * 16, // ybegin, yend
0, 1, // zbegin, zend
0, 1); // chbegin, chend
ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT );
if( is_smf(tilemapFile) ) {
// Load from SMF
SMF sourcesmf(tilemapFile);
imageBuf = sourcesmf.getTilemap();
}
if( !imageBuf ) {
// load image file
imageBuf = new ImageBuf( tilemapFile );
imageBuf->read( 0, 0, false, TypeDesc::UINT );
if( !imageBuf->initialized() ) {
delete imageBuf;
imageBuf = NULL;
}
}
if( !imageBuf ) {
// Generate blank
imageBuf = new ImageBuf( "tilemap", imageSpec );
for ( unsigned int i = 0; i < imageSpec.image_pixels(); ++i )
((unsigned int *)imageBuf->localpixels())[ i ] = i;
}
imageSpec = imageBuf->specmod();
ImageBuf fixBuf;
// Fix the number of channels
if( imageSpec.nchannels != roi.chend ) {
int map[] = {0};
ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
// Fix the size
// FIXME image should never be resized, instead tiling either from an edge or centred.
if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) {
if( verbose )
printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n",
tilemapFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend );
ImageBufAlgo::resample(fixBuf, *imageBuf, false, roi);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
unsigned int *pixels = (unsigned int *)imageBuf->localpixels();
// write the data to the smf
smf.write( (char *)pixels, imageBuf->spec().image_bytes() );
smf.close();
delete imageBuf;
if( is_smf( tilemapFile ) ) delete [] pixels;
return false;
}
bool
SMF::saveMetal()
{
if( verbose )cout << "INFO: saveMetal\n";
// Dimensions of displacement map.
ImageBuf *imageBuf = NULL;
ROI roi( 0, width * 32, // xbegin, xend
0, length * 32, // ybegin, yend
0, 1, // zbegin, zend
0, 1); // chbegin, chend
ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 );
if( is_smf(metalFile) ) {
// Load from smf
SMF sourcesmf(metalFile);
imageBuf = sourcesmf.getMetal();
}
if( !imageBuf ) {
//load from image
imageBuf = new ImageBuf(metalFile);
imageBuf->read( 0, 0, false, TypeDesc::UINT8 );
if( !imageBuf->initialized() ) {
delete imageBuf;
imageBuf = NULL;
}
}
if( !imageBuf ) {
// Generate blank
imageBuf = new ImageBuf( "metal", imageSpec );
}
imageSpec = imageBuf->specmod();
ImageBuf fixBuf;
// Fix the number of channels
if( imageSpec.nchannels != roi.chend ) {
int map[] = {0};
ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
// Fix the size
if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) {
if( verbose )
printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n",
metalFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend );
ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
unsigned char *pixels = (unsigned char *)imageBuf->localpixels();
char filename[256];
sprintf( filename, "%s.smf", outPrefix.c_str() );
fstream smf(filename, ios::binary | ios::in | ios::out);
smf.seekp(metalPtr);
// write the data to the smf
smf.write( (char *)pixels, imageBuf->spec().image_bytes() );
smf.close();
delete imageBuf;
if( is_smf( metalFile ) ) delete [] pixels;
return false;
}
bool
SMF::saveMinimap()
{
if( verbose )cout << "INFO: saveMinimap\n";
char filename[256];
sprintf( filename, "%s.smf", outPrefix.c_str() );
fstream smf(filename, ios::binary | ios::in | ios::out);
smf.seekp(minimapPtr);
unsigned char *pixels;
if( is_smf(minimapFile) ) {
// Copy from SMF
pixels = new unsigned char[MINIMAP_SIZE];
ifstream inFile(minimapFile.c_str(), ifstream::in);
inFile.seekg(header.minimapPtr);
inFile.read( (char *)pixels, MINIMAP_SIZE);
inFile.close();
smf.write( (char *)pixels, MINIMAP_SIZE);
smf.close();
delete [] pixels;
return false;
}
//OpenImageIO
ROI roi( 0, 1024,
0, 1024,
0, 1,
0, 4);
ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT8 );
// Load image file
ImageBuf *imageBuf = new ImageBuf( minimapFile );
imageBuf->read( 0, 0, false, TypeDesc::UINT8 );
//FIXME attempt to generate minimap from tile files.
if( !imageBuf->initialized() ) {
// Create from height
imageBuf->reset( minimapFile );
imageBuf->read( 0, 0, false, TypeDesc::UINT8 );
}
if( !imageBuf->initialized() ) {
// Create blank
imageBuf->reset( "minimap", imageSpec);
}
imageSpec = imageBuf->specmod();
ImageBuf fixBuf;
// Fix channels
if( imageSpec.nchannels != roi.chend ) {
int map[] = {2,1,0,3};
float fill[] = {0,0,0,255};
ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map, fill);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
// Fix dimensions
if( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) {
printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n",
minimapFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend );
ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
pixels = (unsigned char *)imageBuf->localpixels();
// setup DXT1 Compression
nvtt::InputOptions inputOptions;
inputOptions.setTextureLayout( nvtt::TextureType_2D, 1024, 1024 );
inputOptions.setMipmapData( pixels, 1024, 1024 );
nvtt::CompressionOptions compressionOptions;
compressionOptions.setFormat( nvtt::Format_DXT1 );
if( slowcomp ) compressionOptions.setQuality( nvtt::Quality_Normal );
else compressionOptions.setQuality( nvtt::Quality_Fastest );
nvtt::OutputOptions outputOptions;
outputOptions.setOutputHeader( false );
NVTTOutputHandler *outputHandler = new NVTTOutputHandler(MINIMAP_SIZE + 1);
outputOptions.setOutputHandler( outputHandler );
nvtt::Compressor compressor;
compressor.process( inputOptions, compressionOptions, outputOptions );
// Write data to smf
smf.write( outputHandler->buffer, MINIMAP_SIZE );
delete outputHandler;
smf.close();
delete imageBuf;
return false;
}
bool
SMF::saveHeight()
{
if( verbose )cout << "INFO: saveHeight\n";
// Dimensions of displacement map.
ImageBuf *imageBuf = NULL;
ROI roi( 0, width * 64 + 1, // xbegin, xend
0, length * 64 + 1, // ybegin, yend
0, 1, // zbegin, zend
0, 1); // chbegin, chend
ImageSpec imageSpec( roi.xend, roi.yend, roi.chend, TypeDesc::UINT16 );
if( is_smf(heightFile) ) {
// Load from SMF
SMF sourcesmf(heightFile);
imageBuf = sourcesmf.getHeight();
}
if( !imageBuf ) {
// load image file
imageBuf = new ImageBuf( heightFile );
imageBuf->read( 0, 0, false, TypeDesc::UINT16 );
if( !imageBuf->initialized() ) {
delete imageBuf;
imageBuf = NULL;
}
}
if( !imageBuf ) {
// Generate blank
imageBuf = new ImageBuf( "height", imageSpec );
}
imageSpec = imageBuf->specmod();
ImageBuf fixBuf;
// Fix the number of channels
if( imageSpec.nchannels != roi.chend ) {
int map[] = {0};
ImageBufAlgo::channels(fixBuf, *imageBuf, roi.chend, map);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
// Fix the size
if ( imageSpec.width != roi.xend || imageSpec.height != roi.yend ) {
if( verbose )
printf( "\tWARNING: %s is (%i,%i), wanted (%i, %i), Resampling.\n",
heightFile.c_str(), imageSpec.width, imageSpec.height, roi.xend, roi.yend );
ImageBufAlgo::resample(fixBuf, *imageBuf, true, roi);
imageBuf->copy(fixBuf);
fixBuf.clear();
}
// Invert height
if ( invert ) {
ImageSpec fixSpec(roi.xend, roi.yend, roi.chend, TypeDesc::UINT16);
fixBuf.reset( "fixBuf", fixSpec );
const float fill[] = {65535};
ImageBufAlgo::fill(fixBuf, fill);
ImageBufAlgo::sub(*imageBuf, fixBuf, *imageBuf);
fixBuf.clear();
}
// FIXME filter to remove stepping artifacts from 8bit images,
// if ( lowpass ) {
// }
unsigned short *pixels = (unsigned short *)imageBuf->localpixels();
// write height data to smf.
char filename[256];
sprintf( filename, "%s.smf", outPrefix.c_str() );
fstream smf(filename, ios::binary | ios::in| ios::out);
smf.seekp(heightPtr);
smf.write( (char *)pixels, imageBuf->spec().image_bytes() );
smf.close();
delete imageBuf;
if( is_smf( heightFile ) ) delete [] pixels;
return false;
}
