bool
ImageBufAlgo::transpose (ImageBuf &dst, const ImageBuf &src,
ROI roi, int nthreads)
{
pvt::LoggedTimer logtime("IBA::transpose");
if (! roi.defined())
roi = get_roi (src.spec());
roi.chend = std::min (roi.chend, src.nchannels());
ROI dst_roi (roi.ybegin, roi.yend, roi.xbegin, roi.xend,
roi.zbegin, roi.zend, roi.chbegin, roi.chend);
bool dst_initialized = dst.initialized();
if (! IBAprep (dst_roi, &dst))
return false;
if (! dst_initialized) {
ROI r = src.roi_full();
ROI dst_roi_full (r.ybegin, r.yend, r.xbegin, r.xend,
r.zbegin, r.zend, r.chbegin, r.chend);
dst.set_roi_full (dst_roi_full);
}
bool ok;
if (dst.spec().format == src.spec().format) {
OIIO_DISPATCH_TYPES (ok, "transpose", transpose_, dst.spec().format,
dst, src, roi, nthreads);
} else {
OIIO_DISPATCH_COMMON_TYPES2 (ok, "transpose", transpose_, dst.spec().format,
src.spec().format, dst, src, roi, nthreads);
}
return ok;
}
ImageBuf *
SMT::reconstructBig()
{
if( verbose )cout << "INFO: Reconstructing Big\n";
ImageBuf *tileBuf = NULL;
//Load tilemap from SMF
ImageBuf *tilemapBuf = NULL;
if( is_smf( tilemapFile ) ) {
SMF sourcesmf(tilemapFile);
tilemapBuf = sourcesmf.getTilemap();
}
// Else load tilemap from image
if( !tilemapBuf ) {
tilemapBuf = new ImageBuf( tilemapFile );
tilemapBuf->read(0,0,false,TypeDesc::UINT);
if( !tilemapBuf->initialized() ) {
delete tilemapBuf;
if( !quiet )printf("ERROR: %s cannot be loaded.\n",
tilemapFile.c_str());
return NULL;
}
}
//TODO Else load tilemap from csv
unsigned int *tilemap = (unsigned int *)tilemapBuf->localpixels();
int xtiles = tilemapBuf->spec().width;
int ztiles = tilemapBuf->spec().height;
// allocate enough data for our large image
ImageSpec bigSpec( xtiles * tileRes, ztiles * tileRes, 4, TypeDesc::UINT8 );
ImageBuf *bigBuf = new ImageBuf( "big", bigSpec );
// Loop through tile index
for( int z = 0; z < ztiles; ++z ) {
for( int x = 0; x < xtiles; ++x ) {
int tilenum = tilemap[z * xtiles + x];
tileBuf = getTile(tilenum);
int xbegin = tileRes * x;
int ybegin = tileRes * z;
ImageBufAlgo::paste(*bigBuf, xbegin, ybegin, 0, 0, *tileBuf);
delete [] (unsigned char *)tileBuf->localpixels();
delete tileBuf;
if( verbose )printf("\033[0GINFO: Processing tile %i of %i.",
z * xtiles + x, xtiles * ztiles );
}
}
cout << endl;
delete tilemapBuf;
if( is_smf( tilemapFile ) ) delete [] tilemap;
return bigBuf;
}
bool
ImageBufAlgo::mad (ImageBuf &dst, const ImageBuf &A, const float *B,
const float *C, ROI roi, int nthreads)
{
if (!A.initialized()) {
dst.error ("Uninitialized input image");
return false;
}
if (! IBAprep (roi, &dst, &A))
return false;
bool ok;
OIIO_DISPATCH_COMMON_TYPES2 (ok, "mad", mad_implf, dst.spec().format,
A.spec().format, dst, A, B, C,
roi, nthreads);
return ok;
}
bool
ImageBufAlgo::mad (ImageBuf &dst, const ImageBuf &A, float b,
float c, ROI roi, int nthreads)
{
if (!A.initialized()) {
dst.error ("Uninitialized input image");
return false;
}
if (! IBAprep (roi, &dst, &A))
return false;
std::vector<float> B (roi.chend, b);
std::vector<float> C (roi.chend, c);
bool ok;
OIIO_DISPATCH_COMMON_TYPES2 (ok, "mad", mad_implf, dst.spec().format,
A.spec().format, dst, A, &B[0], &C[0],
roi, nthreads);
return ok;
}
bool
ImageBufAlgo::rotate270 (ImageBuf &dst, const ImageBuf &src,
ROI roi, int nthreads)
{
if (&dst == &src) { // Handle in-place operation
ImageBuf tmp;
tmp.swap (const_cast<ImageBuf&>(src));
return rotate270 (dst, tmp, roi, nthreads);
}
pvt::LoggedTimer logtime("IBA::rotate270");
ROI src_roi = roi.defined() ? roi : src.roi();
ROI src_roi_full = src.roi_full();
// Rotated full ROI swaps width and height, and keeps its origin
// where the original origin was.
ROI dst_roi_full (src_roi_full.xbegin, src_roi_full.xbegin+src_roi_full.height(),
src_roi_full.ybegin, src_roi_full.ybegin+src_roi_full.width(),
src_roi_full.zbegin, src_roi_full.zend,
src_roi_full.chbegin, src_roi_full.chend);
ROI dst_roi (src_roi.ybegin, src_roi.yend,
src_roi_full.xend-src_roi.xend,
src_roi_full.xend-src_roi.xbegin,
src_roi.zbegin, src_roi.zend,
src_roi.chbegin, src_roi.chend);
ASSERT (dst_roi.width() == src_roi.height() &&
dst_roi.height() == src_roi.width());
bool dst_initialized = dst.initialized();
if (! IBAprep (dst_roi, &dst, &src))
return false;
if (! dst_initialized)
dst.set_roi_full (dst_roi_full);
bool ok;
OIIO_DISPATCH_COMMON_TYPES2 (ok, "rotate270", rotate270_,
dst.spec().format, src.spec().format,
dst, src, dst_roi, nthreads);
return ok;
}
bool
ImageBufAlgo::transpose (ImageBuf &dst, const ImageBuf &src,
ROI roi, int nthreads)
{
if (! roi.defined())
roi = get_roi (src.spec());
roi.chend = std::min (roi.chend, src.nchannels());
ROI dst_roi (roi.ybegin, roi.yend, roi.xbegin, roi.xend,
roi.zbegin, roi.zend, roi.chbegin, roi.chend);
bool dst_initialized = dst.initialized();
IBAprep (dst_roi, &dst);
if (! dst_initialized) {
ROI r = src.roi_full();
ROI dst_roi_full (r.ybegin, r.yend, r.xbegin, r.xend,
r.zbegin, r.zend, r.chbegin, r.chend);
dst.set_roi_full (dst_roi_full);
}
bool ok;
OIIO_DISPATCH_TYPES2 (ok, "transpose", transpose_, dst.spec().format,
src.spec().format, dst, src, roi, nthreads);
return ok;
}
ImageBuf *
SMT::buildBig()
{
if( verbose && sourceFiles.size() > 1 ) {
cout << "INFO: Collating source images\n";
cout << " nFiles: " << sourceFiles.size() << endl;
cout << " stride: " << stride << endl;
if( sourceFiles.size() % stride != 0 )
cout << "WARNING: number of source files isnt divisible by stride,"
" black spots will exist\n";
}
// Get values to fix
ImageBuf *regionBuf = new ImageBuf(sourceFiles[0]);
regionBuf->read(0,0,false, TypeDesc::UINT8);
if( !regionBuf->initialized() ) {
if( !quiet )printf("ERROR: could not build big image\n");
return NULL;
}
ImageSpec regionSpec = regionBuf->spec();
delete regionBuf;
// Construct the big buffer
ImageSpec bigSpec(
regionSpec.width * stride,
regionSpec.height * sourceFiles.size() / stride,
4,
TypeDesc::UINT8 );
if( verbose )printf(" Allocating: (%i,%i)%i\n",
bigSpec.width, bigSpec.height, bigSpec.nchannels );
ImageBuf *bigBuf = new ImageBuf( "big", bigSpec );
// Fill the alpha channel
const float fill[] = { 0, 0, 0, 255 };
ImageBufAlgo::fill( *bigBuf, fill );
// Collate the source Files
int nFiles = sourceFiles.size();
for( int i = 0; i < nFiles; ++i ) {
if( verbose )printf( "\033[0G copying %i of %i, %s",
i + 1, nFiles, sourceFiles[i].c_str() );
regionBuf = new ImageBuf( sourceFiles[i] );
regionBuf->read( 0, 0, false, TypeDesc::UINT8 );
if( !regionBuf->initialized() ) {
if( !quiet )printf( "\nERROR: %s could not be loaded.\n",
sourceFiles[i].c_str() );
continue;
}
regionSpec = regionBuf->spec();
int x = regionSpec.width * (i % stride);
int y = regionSpec.height * (i / stride);
y = bigSpec.height - y - regionSpec.height;
ImageBufAlgo::paste( *bigBuf, x, y, 0, 0, *regionBuf );
}
if( verbose )cout << endl;
// rescale constructed big image to wanted size
ROI roi( 0, width * 512 , 0, length * 512, 0, 1, 0, 4 );
ImageBuf fixBuf;
if( bigSpec.width != roi.xend || bigSpec.height != roi.yend ) {
if( verbose )
printf( "WARNING: Image is (%i,%i), wanted (%i, %i),"
" Resampling.\n",
bigSpec.width, bigSpec.height, roi.xend, roi.yend );
ImageBufAlgo::resample( fixBuf, *bigBuf, true, roi );
bigBuf->copy( fixBuf );
}
return bigBuf;
}
IplImage *
ImageBufAlgo::to_IplImage (const ImageBuf &src)
{
#ifdef USE_OPENCV
ImageBuf tmp = src;
ImageSpec spec = tmp.spec();
// Make sure the image buffer is initialized.
if (!tmp.initialized() && !tmp.read(tmp.subimage(), tmp.miplevel(), true)) {
DASSERT (0 && "Could not initialize ImageBuf.");
return NULL;
}
int dstFormat;
TypeDesc dstSpecFormat;
if (spec.format == TypeDesc(TypeDesc::UINT8)) {
dstFormat = IPL_DEPTH_8U;
dstSpecFormat = spec.format;
} else if (spec.format == TypeDesc(TypeDesc::INT8)) {
dstFormat = IPL_DEPTH_8S;
dstSpecFormat = spec.format;
} else if (spec.format == TypeDesc(TypeDesc::UINT16)) {
dstFormat = IPL_DEPTH_16U;
dstSpecFormat = spec.format;
} else if (spec.format == TypeDesc(TypeDesc::INT16)) {
dstFormat = IPL_DEPTH_16S;
dstSpecFormat = spec.format;
} else if (spec.format == TypeDesc(TypeDesc::HALF)) {
dstFormat = IPL_DEPTH_32F;
// OpenCV does not support half types. Switch to float instead.
dstSpecFormat = TypeDesc(TypeDesc::FLOAT);
} else if (spec.format == TypeDesc(TypeDesc::FLOAT)) {
dstFormat = IPL_DEPTH_32F;
dstSpecFormat = spec.format;
} else if (spec.format == TypeDesc(TypeDesc::DOUBLE)) {
dstFormat = IPL_DEPTH_64F;
dstSpecFormat = spec.format;
} else {
DASSERT (0 && "Unknown data format in ImageBuf.");
return NULL;
}
IplImage *ipl = cvCreateImage(cvSize(spec.width, spec.height), dstFormat, spec.nchannels);
if (!ipl) {
DASSERT (0 && "Unable to create IplImage.");
return NULL;
}
size_t pixelsize = dstSpecFormat.size() * spec.nchannels;
// Account for the origin in the line step size, to end up with the
// standard OIIO origin-at-upper-left:
size_t linestep = ipl->origin ? -ipl->widthStep : ipl->widthStep;
bool converted = convert_image(spec.nchannels, spec.width, spec.height, 1,
tmp.localpixels(), spec.format,
spec.pixel_bytes(), spec.scanline_bytes(), 0,
ipl->imageData, dstSpecFormat,
pixelsize, linestep, 0);
if (!converted) {
DASSERT (0 && "convert_image failed.");
cvReleaseImage(&ipl);
return NULL;
}
// OpenCV uses BGR ordering
if (spec.nchannels == 3) {
cvCvtColor(ipl, ipl, CV_RGB2BGR);
} else if (spec.nchannels == 4) {
cvCvtColor(ipl, ipl, CV_RGBA2BGRA);
}
return ipl;
#else
return NULL;
#endif
}
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;
}
