static void
time_read_imagebuf ()
{
ImageBuf ib (input_filename.string(), imagecache);
ib.read (0, 0, true, TypeDesc::TypeFloat);
imagecache->invalidate_all (true);
}
// Test ability to do a maketx directly from an ImageBuf
void
test_maketx_from_imagebuf()
{
std::cout << "test make_texture from ImageBuf\n";
// Make a checkerboard
const int WIDTH = 16, HEIGHT = 16, CHANNELS = 3;
ImageSpec spec (WIDTH, HEIGHT, CHANNELS, TypeDesc::FLOAT);
ImageBuf A (spec);
float pink[] = { .5, .3, .3 }, green[] = { .1, .5, .1 };
ImageBufAlgo::checker (A, 4, 4, 4, pink, green);
// Write it
const char *pgname = "oiio-pgcheck.tx";
remove (pgname); // Remove it first
ImageSpec configspec;
ImageBufAlgo::make_texture (ImageBufAlgo::MakeTxTexture, A,
pgname, configspec);
// Read it back and compare it
ImageBuf B (pgname);
B.read ();
ImageBufAlgo::CompareResults comparison;
ImageBufAlgo::compare (A, B, 0, 0, comparison);
OIIO_CHECK_EQUAL (comparison.nwarn, 0);
OIIO_CHECK_EQUAL (comparison.nfail, 0);
remove (pgname); // clean up
}
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;
}
static bool
read_input (const std::string &filename, ImageBuf &img,
int subimage=0, int miplevel=0)
{
if (img.subimage() >= 0 && img.subimage() == subimage)
return true;
if (img.init_spec (filename, subimage, miplevel) &&
img.read (subimage, miplevel, false, TypeDesc::FLOAT))
return true;
return false;
}
static bool
read_input (const std::string &filename, ImageBuf &img,
int subimage=0, int miplevel=0)
{
if (img.subimage() >= 0 && img.subimage() == subimage)
return true;
if (img.init_spec (filename, subimage, miplevel) &&
img.read (subimage, miplevel, false, TypeDesc::FLOAT))
return true;
std::cerr << "oiiotool ERROR: Could not read " << filename << ":\n\t"
<< img.geterror() << "\n";
return false;
}
static bool
read_input (const std::string &filename, ImageBuf &img,
ImageCache *cache, int subimage=0, int miplevel=0)
{
if (img.subimage() >= 0 &&
img.subimage() == subimage && img.miplevel() == miplevel)
return true;
img.reset (filename, cache);
if (img.read (subimage, miplevel, false, TypeDesc::TypeFloat))
return true;
std::cerr << "idiff ERROR: Could not read " << filename << ":\n\t"
<< img.geterror() << "\n";
return false;
}
static bool
read_input (const std::string &filename, ImageBuf &img,
int subimage=0, int miplevel=0)
{
if (img.subimage() >= 0 && img.subimage() == subimage)
return true;
if (img.init_spec (filename, subimage, miplevel)) {
// Force a read now for reasonable-sized first images in the
// file. This can greatly speed up the multithread case for
// tiled images by not having multiple threads working on the
// same image lock against each other on the file handle.
// We guess that "reasonable size" is 200 MB, that's enough to
// hold a 4k RGBA float image. Larger things will
// simply fall back on ImageCache.
bool forceread = (img.spec().image_bytes() < 200*1024*1024);
return img.read (subimage, miplevel, forceread, TypeDesc::FLOAT);
}
return false;
}
ImageRec::ImageRec (ImageRec &img, int subimage_to_copy,
int miplevel_to_copy, bool writable, bool copy_pixels)
: m_name(img.name()), m_elaborated(true),
m_metadata_modified(false), m_pixels_modified(false),
m_was_output(false),
m_imagecache(img.m_imagecache)
{
img.read ();
int first_subimage = std::max (0, subimage_to_copy);
int subimages = (subimage_to_copy < 0) ? img.subimages() : 1;
m_subimages.resize (subimages);
for (int s = 0; s < subimages; ++s) {
int srcsub = s + first_subimage;
int first_miplevel = std::max (0, miplevel_to_copy);
int miplevels = (miplevel_to_copy < 0) ? img.miplevels(srcsub) : 1;
m_subimages[s].m_miplevels.resize (miplevels);
m_subimages[s].m_specs.resize (miplevels);
for (int m = 0; m < miplevels; ++m) {
int srcmip = m + first_miplevel;
const ImageBuf &srcib (img(srcsub,srcmip));
const ImageSpec &srcspec (*img.spec(srcsub,srcmip));
ImageBuf *ib = NULL;
if (writable || img.pixels_modified() || !copy_pixels) {
// Make our own copy of the pixels
ib = new ImageBuf (srcspec);
if (copy_pixels)
ib->copy_pixels (srcib);
} else {
// The other image is not modified, and we don't need to be
// writable, either.
ib = new ImageBuf (img.name(), srcib.imagecache());
bool ok = ib->read (srcsub, srcmip, false /*force*/,
img.m_input_dataformat /*convert*/);
ASSERT (ok);
}
m_subimages[s].m_miplevels[m].reset (ib);
m_subimages[s].m_specs[m] = srcspec;
}
}
}
bool
ImageRec::read (ReadPolicy readpolicy)
{
if (elaborated())
return true;
static ustring u_subimages("subimages"), u_miplevels("miplevels");
static boost::regex regex_sha ("SHA-1=[[:xdigit:]]*[ ]*");
int subimages = 0;
ustring uname (name());
if (! m_imagecache->get_image_info (uname, 0, 0, u_subimages,
TypeDesc::TypeInt, &subimages)) {
error ("file not found: \"%s\"", name());
return false; // Image not found
}
m_subimages.resize (subimages);
bool allok = true;
for (int s = 0; s < subimages; ++s) {
int miplevels = 0;
m_imagecache->get_image_info (uname, s, 0, u_miplevels,
TypeDesc::TypeInt, &miplevels);
m_subimages[s].m_miplevels.resize (miplevels);
m_subimages[s].m_specs.resize (miplevels);
for (int m = 0; m < miplevels; ++m) {
// Force a read now for reasonable-sized first images in the
// file. This can greatly speed up the multithread case for
// tiled images by not having multiple threads working on the
// same image lock against each other on the file handle.
// We guess that "reasonable size" is 50 MB, that's enough to
// hold a 2048x1536 RGBA float image. Larger things will
// simply fall back on ImageCache.
bool forceread = (s == 0 && m == 0 &&
m_imagecache->imagespec(uname,s,m)->image_bytes() < 50*1024*1024);
ImageBuf *ib = new ImageBuf (name(), m_imagecache);
// If we were requested to bypass the cache, force a full read.
if (readpolicy & ReadNoCache)
forceread = true;
// Convert to float unless asked to keep native.
TypeDesc convert = (readpolicy & ReadNative)
? ib->nativespec().format : TypeDesc::FLOAT;
if (! forceread &&
convert != TypeDesc::UINT8 && convert != TypeDesc::UINT16 &&
convert != TypeDesc::HALF && convert != TypeDesc::FLOAT) {
// If we're still trying to use the cache but it doesn't
// support the native type, force a full read.
forceread = true;
}
bool ok = ib->read (s, m, forceread, convert);
if (!ok)
error ("%s", ib->geterror());
allok &= ok;
// Remove any existing SHA-1 hash from the spec.
ib->specmod().erase_attribute ("oiio:SHA-1");
std::string desc = ib->spec().get_string_attribute ("ImageDescription");
if (desc.size())
ib->specmod().attribute ("ImageDescription",
boost::regex_replace (desc, regex_sha, ""));
m_subimages[s].m_miplevels[m].reset (ib);
m_subimages[s].m_specs[m] = ib->spec();
// For ImageRec purposes, we need to restore a few of the
// native settings.
const ImageSpec &nativespec (ib->nativespec());
// m_subimages[s].m_specs[m].format = nativespec.format;
m_subimages[s].m_specs[m].tile_width = nativespec.tile_width;
m_subimages[s].m_specs[m].tile_height = nativespec.tile_height;
m_subimages[s].m_specs[m].tile_depth = nativespec.tile_depth;
}
}
m_time = Filesystem::last_write_time (name());
m_elaborated = true;
return allok;
}
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::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;
}
static void
make_texturemap (const char *maptypename = "texture map")
{
if (filenames.size() != 1) {
std::cerr << "maketx ERROR: " << maptypename
<< " requires exactly one input filename\n";
exit (EXIT_FAILURE);
}
if (! Filesystem::exists (filenames[0])) {
std::cerr << "maketx ERROR: \"" << filenames[0] << "\" does not exist\n";
exit (EXIT_FAILURE);
}
if (outputfilename.empty()) {
std::string ext = boost::filesystem::extension (filenames[0]);
int notextlen = (int) filenames[0].length() - (int) ext.length();
outputfilename = std::string (filenames[0].begin(),
filenames[0].begin() + notextlen);
outputfilename += ".tx";
}
// When was the input file last modified?
std::time_t in_time = boost::filesystem::last_write_time (filenames[0]);
// When in update mode, skip making the texture if the output already
// exists and has the same file modification time as the input file.
if (updatemode && Filesystem::exists (outputfilename) &&
(in_time == boost::filesystem::last_write_time (outputfilename))) {
std::cout << "maketx: no update required for \""
<< outputfilename << "\"\n";
return;
}
ImageBuf src (filenames[0]);
src.init_spec (filenames[0], 0, 0); // force it to get the spec, not read
// The cache might mess with the apparent data format. But for the
// purposes of what we should output, figure it out now, before the
// file has been read and cached.
TypeDesc out_dataformat = src.spec().format;
// Figure out which data format we want for output
if (! dataformatname.empty()) {
if (dataformatname == "uint8")
out_dataformat = TypeDesc::UINT8;
else if (dataformatname == "int8" || dataformatname == "sint8")
out_dataformat = TypeDesc::INT8;
else if (dataformatname == "uint16")
out_dataformat = TypeDesc::UINT16;
else if (dataformatname == "int16" || dataformatname == "sint16")
out_dataformat = TypeDesc::INT16;
else if (dataformatname == "half")
out_dataformat = TypeDesc::HALF;
else if (dataformatname == "float")
out_dataformat = TypeDesc::FLOAT;
else if (dataformatname == "double")
out_dataformat = TypeDesc::DOUBLE;
}
// We cannot compute the prman / oiio options until after out_dataformat
// has been determined, as it's required (and can potentially change
// out_dataformat too!)
if (prman) out_dataformat = set_prman_options (out_dataformat);
else if (oiio) out_dataformat = set_oiio_options (out_dataformat);
// Read the full file locally if it's less than 1 GB, otherwise
// allow the ImageBuf to use ImageCache to manage memory.
bool read_local = (src.spec().image_bytes() < size_t(1024*1024*1024));
if (verbose)
std::cout << "Reading file: " << filenames[0] << std::endl;
Timer readtimer;
if (! src.read (0, 0, read_local)) {
std::cerr
<< "maketx ERROR: Could not read \""
<< filenames[0] << "\" : " << src.geterror() << "\n";
exit (EXIT_FAILURE);
}
stat_readtime += readtimer();
// If requested - and we're a constant color - make a tiny texture instead
std::vector<float> constantColor(src.nchannels());
bool isConstantColor = ImageBufAlgo::isConstantColor (src, &constantColor[0]);
if (isConstantColor && constant_color_detect) {
int newwidth = std::max (1, std::min (src.spec().width, tile[0]));
int newheight = std::max (1, std::min (src.spec().height, tile[1]));
ImageSpec newspec = src.spec();
newspec.x = 0;
newspec.y = 0;
newspec.z = 0;
newspec.width = newwidth;
newspec.height = newheight;
newspec.depth = 1;
newspec.full_x = 0;
newspec.full_y = 0;
newspec.full_z = 0;
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
newspec.full_depth = newspec.depth;
// Reset the image, to a new image, at the new size
std::string name = src.name() + ".constant_color";
src.reset(name, newspec);
ImageBufAlgo::fill (src, &constantColor[0]);
if (verbose) {
std::cout << " Constant color image detected. ";
std::cout << "Creating " << newspec.width << "x" << newspec.height << " texture instead.\n";
}
}
// If requested - and we're a monochrome image - drop the extra channels
if (monochrome_detect && (src.nchannels() > 1) && ImageBufAlgo::isMonochrome(src)) {
ImageBuf newsrc(src.name() + ".monochrome", src.spec());
ImageBufAlgo::setNumChannels (newsrc, src, 1);
src = newsrc;
if (verbose) {
std::cout << " Monochrome image detected. Converting to single channel texture.\n";
}
}
// Or, if we've otherwise explicitly requested to write out a
// specific number of channels, do it.
else if ((nchannels > 0) && (nchannels != src.nchannels())) {
ImageBuf newsrc(src.name() + ".channels", src.spec());
ImageBufAlgo::setNumChannels (newsrc, src, nchannels);
src = newsrc;
if (verbose) {
std::cout << " Overriding number of channels to " << nchannels << "\n";
}
}
if (shadowmode) {
// Some special checks for shadow maps
if (src.spec().nchannels != 1) {
std::cerr << "maketx ERROR: shadow maps require 1-channel images,\n"
<< "\t\"" << filenames[0] << "\" is "
<< src.spec().nchannels << " channels\n";
exit (EXIT_FAILURE);
}
// Shadow maps only make sense for floating-point data.
if (out_dataformat != TypeDesc::FLOAT &&
out_dataformat != TypeDesc::HALF &&
out_dataformat != TypeDesc::DOUBLE)
out_dataformat = TypeDesc::FLOAT;
}
// Copy the input spec
const ImageSpec &srcspec = src.spec();
ImageSpec dstspec = srcspec;
// Make the output not a crop window
dstspec.x = 0;
dstspec.y = 0;
dstspec.z = 0;
dstspec.width = srcspec.full_width;
dstspec.height = srcspec.full_height;
dstspec.depth = srcspec.full_depth;
dstspec.full_x = 0;
dstspec.full_y = 0;
dstspec.full_z = 0;
dstspec.full_width = dstspec.width;
dstspec.full_height = dstspec.height;
dstspec.full_depth = dstspec.depth;
bool orig_was_crop = (srcspec.x != 0 || srcspec.y != 0 || srcspec.z != 0 ||
srcspec.full_width != srcspec.width ||
srcspec.full_height != srcspec.height ||
srcspec.full_depth != srcspec.depth);
// Make the output tiled, regardless of input
dstspec.tile_width = tile[0];
dstspec.tile_height = tile[1];
dstspec.tile_depth = tile[2];
// Always use ZIP compression
dstspec.attribute ("compression", "zip");
// Ugh, the line above seems to trigger a bug in the tiff library.
// Maybe a bug in libtiff zip compression for tiles? So let's
// stick to the default compression.
// Put a DateTime in the out file, either now, or matching the date
// stamp of the input file (if update mode).
time_t date;
if (updatemode)
date = in_time; // update mode: use the time stamp of the input
else
time (&date); // not update: get the time now
dstspec.attribute ("DateTime", datestring(date));
dstspec.attribute ("Software", full_command_line);
if (shadowmode) {
dstspec.attribute ("textureformat", "Shadow");
if (prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Shadow");
} else if (envlatlmode) {
dstspec.attribute ("textureformat", "LatLong Environment");
swrap = "periodic";
twrap = "clamp";
if (prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Latlong Environment");
} else {
dstspec.attribute ("textureformat", "Plain Texture");
if(prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Plain Texture");
}
if (Mcam != Imath::M44f(0.0f))
dstspec.attribute ("worldtocamera", TypeDesc::TypeMatrix, &Mcam);
if (Mscr != Imath::M44f(0.0f))
dstspec.attribute ("worldtoscreen", TypeDesc::TypeMatrix, &Mscr);
// FIXME - check for valid strings in the wrap mode
if (! shadowmode) {
std::string wrapmodes = (swrap.size() ? swrap : wrap) + ',' +
(twrap.size() ? twrap : wrap);
dstspec.attribute ("wrapmodes", wrapmodes);
}
if(fovcot == 0.0f) {
fovcot = static_cast<float>(srcspec.full_width) /
static_cast<float>(srcspec.full_height);
}
dstspec.attribute ("fovcot", fovcot);
if (separate)
dstspec.attribute ("planarconfig", "separate");
else {
dstspec.erase_attribute("planarconfig");
dstspec.erase_attribute("tiff:planarconfig");
}
// FIXME -- should we allow tile sizes to reduce if the image is
// smaller than the tile size? And when we do, should we also try
// to make it bigger in the other direction to make the total tile
// size more constant?
// If --checknan was used and it's a floating point image, check for
// nonfinite (NaN or Inf) values and abort if they are found.
if (checknan && (srcspec.format.basetype == TypeDesc::FLOAT ||
srcspec.format.basetype == TypeDesc::HALF ||
srcspec.format.basetype == TypeDesc::DOUBLE)) {
found_nonfinite = false;
parallel_image (check_nan_block, &src, &src,
dstspec.x, dstspec.x+dstspec.width,
dstspec.y, dstspec.y+dstspec.height, nthreads);
if (found_nonfinite) {
if (found_nonfinite > 3)
std::cerr << "maketx ERROR: ...and Nan/Inf at "
<< (found_nonfinite-3) << " other pixels\n";
exit (EXIT_FAILURE);
}
}
// Force float for the sake of the ImageBuf math
dstspec.set_format (TypeDesc::FLOAT);
// Handle resize to power of two, if called for
if (! noresize && ! shadowmode) {
dstspec.width = pow2roundup (dstspec.width);
dstspec.height = pow2roundup (dstspec.height);
dstspec.full_width = dstspec.width;
dstspec.full_height = dstspec.height;
}
bool do_resize = false;
// Resize if we're up-resing for pow2
if (dstspec.width != srcspec.width || dstspec.height != srcspec.height ||
dstspec.depth != srcspec.depth)
do_resize = true;
// resize if the original was a crop
if (orig_was_crop)
do_resize = true;
// resize if we're converting from non-border sampling to border sampling
if (envlatlmode && ! src_samples_border &&
(iequals(fileformatname,"openexr") || iends_with(outputfilename,".exr")))
do_resize = true;
Timer resizetimer;
ImageBuf dst ("temp", dstspec);
ImageBuf *toplevel = &dst; // Ptr to top level of mipmap
if (! do_resize) {
// Don't need to resize
if (dstspec.format == srcspec.format) {
// Even more special case, no format change -- just use
// the original copy.
toplevel = &src;
} else {
parallel_image (copy_block, &dst, &src,
dstspec.x, dstspec.x+dstspec.width,
dstspec.y, dstspec.y+dstspec.height, nthreads);
}
} else {
// Resize
if (verbose)
std::cout << " Resizing image to " << dstspec.width
<< " x " << dstspec.height << std::endl;
if (filtername == "box" && filter->width() == 1.0f)
parallel_image (resize_block, &dst, &src,
dstspec.x, dstspec.x+dstspec.width,
dstspec.y, dstspec.y+dstspec.height, nthreads);
else
parallel_image (resize_block_HQ, &dst, &src,
dstspec.x, dstspec.x+dstspec.width,
dstspec.y, dstspec.y+dstspec.height, nthreads);
}
stat_resizetime += resizetimer();
// Update the toplevel ImageDescription with the sha1 pixel hash and constant color
std::string desc = dstspec.get_string_attribute ("ImageDescription");
bool updatedDesc = false;
// FIXME: We need to do real dictionary style partial updates on the
// ImageDescription. I.e., set one key without affecting the
// other keys. But in the meantime, just clear it out if
// it appears the incoming image was a maketx style texture.
if ((desc.find ("SHA-1=") != std::string::npos) ||
(desc.find ("ConstantColor=") != std::string::npos)) {
desc = "";
}
// The hash is only computed for the top mipmap level of pixel data.
// Thus, any additional information that will effect the lower levels
// (such as filtering information) needs to be manually added into the
// hash.
std::ostringstream addlHashData;
addlHashData << filter->name() << " ";
addlHashData << filter->width() << " ";
std::string hash_digest = ImageBufAlgo::computePixelHashSHA1 (*toplevel,
addlHashData.str());
if (hash_digest.length()) {
if (desc.length())
desc += " ";
desc += "SHA-1=";
desc += hash_digest;
if (verbose)
std::cout << " SHA-1: " << hash_digest << std::endl;
updatedDesc = true;
}
if (isConstantColor) {
std::ostringstream os; // Emulate a JSON array
os << "[";
for (unsigned int i=0; i<constantColor.size(); ++i) {
if (i!=0) os << ",";
os << constantColor[i];
}
os << "]";
if (desc.length())
desc += " ";
desc += "ConstantColor=";
desc += os.str();
if (verbose)
std::cout << " ConstantColor: " << os.str() << std::endl;
updatedDesc = true;
}
if (updatedDesc) {
dstspec.attribute ("ImageDescription", desc);
}
// Write out, and compute, the mipmap levels for the speicifed image
std::string outformat = fileformatname.empty() ? outputfilename : fileformatname;
write_mipmap (*toplevel, dstspec, outputfilename, outformat, out_dataformat,
!shadowmode && !nomipmap);
// If using update mode, stamp the output file with a modification time
// matching that of the input file.
if (updatemode)
boost::filesystem::last_write_time (outputfilename, in_time);
}
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;
}
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::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;
}
bool
ImageBufAlgo::make_texture (ImageBufAlgo::MakeTextureMode mode,
const std::vector<std::string> &filenames,
const std::string &_outputfilename,
const ImageSpec &_configspec,
std::ostream *outstream_ptr)
{
ASSERT (mode >= 0 && mode < ImageBufAlgo::_MakeTxLast);
Timer alltime;
ImageSpec configspec = _configspec;
// const char *modenames[] = { "texture map", "shadow map",
// "latlong environment map" };
std::stringstream localstream; // catch output when user doesn't want it
std::ostream &outstream (outstream_ptr ? *outstream_ptr : localstream);
double stat_readtime = 0;
double stat_writetime = 0;
double stat_resizetime = 0;
double stat_miptime = 0;
double stat_colorconverttime = 0;
std::string filename = filenames[0];
if (! Filesystem::exists (filename)) {
outstream << "maketx ERROR: \"" << filename << "\" does not exist\n";
return false;
}
std::string outputfilename = _outputfilename.length() ? _outputfilename
: Filesystem::replace_extension (filename, ".tx");
// When was the input file last modified?
std::time_t in_time = Filesystem::last_write_time (filename);
// When in update mode, skip making the texture if the output already
// exists and has the same file modification time as the input file.
bool updatemode = configspec.get_int_attribute ("maketx:updatemode");
if (updatemode && Filesystem::exists (outputfilename) &&
(in_time == Filesystem::last_write_time (outputfilename))) {
outstream << "maketx: no update required for \""
<< outputfilename << "\"\n";
return true;
}
bool shadowmode = (mode == ImageBufAlgo::MakeTxShadow);
bool envlatlmode = (mode == ImageBufAlgo::MakeTxEnvLatl);
// Find an ImageIO plugin that can open the output file, and open it
std::string outformat = configspec.get_string_attribute ("maketx:fileformatname",
outputfilename);
ImageOutput *out = ImageOutput::create (outformat.c_str());
if (! out) {
outstream
<< "maketx ERROR: Could not find an ImageIO plugin to write "
<< outformat << " files:" << geterror() << "\n";
return false;
}
if (! out->supports ("tiles")) {
outstream << "maketx ERROR: \"" << outputfilename
<< "\" format does not support tiled images\n";
return false;
}
ImageBuf src (filename);
src.init_spec (filename, 0, 0); // force it to get the spec, not read
// The cache might mess with the apparent data format. But for the
// purposes of what we should output, figure it out now, before the
// file has been read and cached.
TypeDesc out_dataformat = src.spec().format;
if (configspec.format != TypeDesc::UNKNOWN)
out_dataformat = configspec.format;
// We cannot compute the prman / oiio options until after out_dataformat
// has been determined, as it's required (and can potentially change
// out_dataformat too!)
if (configspec.get_int_attribute("maketx:prman_options"))
out_dataformat = set_prman_options (out_dataformat, configspec);
else if (configspec.get_int_attribute("maketx:oiio_options"))
out_dataformat = set_oiio_options (out_dataformat, configspec);
// Read the full file locally if it's less than 1 GB, otherwise
// allow the ImageBuf to use ImageCache to manage memory.
bool read_local = (src.spec().image_bytes() < size_t(1024*1024*1024));
bool verbose = configspec.get_int_attribute ("maketx:verbose");
if (verbose)
outstream << "Reading file: " << filename << std::endl;
Timer readtimer;
if (! src.read (0, 0, read_local)) {
outstream
<< "maketx ERROR: Could not read \""
<< filename << "\" : " << src.geterror() << "\n";
return false;
}
stat_readtime += readtimer();
// If requested - and we're a constant color - make a tiny texture instead
// Only safe if the full/display window is the same as the data window.
// Also note that this could affect the appearance when using "black"
// wrap mode at runtime.
std::vector<float> constantColor(src.nchannels());
bool isConstantColor = false;
if (configspec.get_int_attribute("maketx:constant_color_detect") &&
src.spec().x == 0 && src.spec().y == 0 && src.spec().z == 0 &&
src.spec().full_x == 0 && src.spec().full_y == 0 &&
src.spec().full_z == 0 && src.spec().full_width == src.spec().width &&
src.spec().full_height == src.spec().height &&
src.spec().full_depth == src.spec().depth) {
isConstantColor = ImageBufAlgo::isConstantColor (src, &constantColor[0]);
if (isConstantColor) {
// Reset the image, to a new image, at the tile size
ImageSpec newspec = src.spec();
newspec.width = std::min (configspec.tile_width, src.spec().width);
newspec.height = std::min (configspec.tile_height, src.spec().height);
newspec.depth = std::min (configspec.tile_depth, src.spec().depth);
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
newspec.full_depth = newspec.depth;
std::string name = src.name() + ".constant_color";
src.reset(name, newspec);
ImageBufAlgo::fill (src, &constantColor[0]);
if (verbose) {
outstream << " Constant color image detected. ";
outstream << "Creating " << newspec.width << "x" << newspec.height << " texture instead.\n";
}
}
}
int nchannels = configspec.get_int_attribute ("maketx:nchannels", -1);
// If requested -- and alpha is 1.0 everywhere -- drop it.
if (configspec.get_int_attribute("maketx:opaque_detect") &&
src.spec().alpha_channel == src.nchannels()-1 &&
nchannels <= 0 &&
ImageBufAlgo::isConstantChannel(src,src.spec().alpha_channel,1.0f)) {
ImageBuf newsrc(src.name() + ".noalpha", src.spec());
ImageBufAlgo::setNumChannels (newsrc, src, src.nchannels()-1);
src.copy (newsrc);
if (verbose) {
outstream << " Alpha==1 image detected. Dropping the alpha channel.\n";
}
}
// If requested - and we're a monochrome image - drop the extra channels
if (configspec.get_int_attribute("maketx:monochrome_detect") &&
nchannels <= 0 &&
src.nchannels() == 3 && src.spec().alpha_channel < 0 && // RGB only
ImageBufAlgo::isMonochrome(src)) {
ImageBuf newsrc(src.name() + ".monochrome", src.spec());
ImageBufAlgo::setNumChannels (newsrc, src, 1);
src.copy (newsrc);
if (verbose) {
outstream << " Monochrome image detected. Converting to single channel texture.\n";
}
}
// If we've otherwise explicitly requested to write out a
// specific number of channels, do it.
if ((nchannels > 0) && (nchannels != src.nchannels())) {
ImageBuf newsrc(src.name() + ".channels", src.spec());
ImageBufAlgo::setNumChannels (newsrc, src, nchannels);
src.copy (newsrc);
if (verbose) {
outstream << " Overriding number of channels to " << nchannels << "\n";
}
}
if (shadowmode) {
// Some special checks for shadow maps
if (src.spec().nchannels != 1) {
outstream << "maketx ERROR: shadow maps require 1-channel images,\n"
<< "\t\"" << filename << "\" is "
<< src.spec().nchannels << " channels\n";
return false;
}
// Shadow maps only make sense for floating-point data.
if (out_dataformat != TypeDesc::FLOAT &&
out_dataformat != TypeDesc::HALF &&
out_dataformat != TypeDesc::DOUBLE)
out_dataformat = TypeDesc::FLOAT;
}
if (configspec.get_int_attribute("maketx:set_full_to_pixels")) {
// User requested that we treat the image as uncropped or not
// overscan
ImageSpec &spec (src.specmod());
spec.full_x = spec.x = 0;
spec.full_y = spec.y = 0;
spec.full_z = spec.z = 0;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
}
// Copy the input spec
const ImageSpec &srcspec = src.spec();
ImageSpec dstspec = srcspec;
bool orig_was_volume = srcspec.depth > 1 || srcspec.full_depth > 1;
bool orig_was_crop = (srcspec.x > srcspec.full_x ||
srcspec.y > srcspec.full_y ||
srcspec.z > srcspec.full_z ||
srcspec.x+srcspec.width < srcspec.full_x+srcspec.full_width ||
srcspec.y+srcspec.height < srcspec.full_y+srcspec.full_height ||
srcspec.z+srcspec.depth < srcspec.full_z+srcspec.full_depth);
bool orig_was_overscan = (srcspec.x < srcspec.full_x &&
srcspec.y < srcspec.full_y &&
srcspec.x+srcspec.width > srcspec.full_x+srcspec.full_width &&
srcspec.y+srcspec.height > srcspec.full_y+srcspec.full_height &&
(!orig_was_volume || (srcspec.z < srcspec.full_z &&
srcspec.z+srcspec.depth > srcspec.full_z+srcspec.full_depth)));
// Make the output not a crop window
if (orig_was_crop) {
dstspec.x = 0;
dstspec.y = 0;
dstspec.z = 0;
dstspec.width = srcspec.full_width;
dstspec.height = srcspec.full_height;
dstspec.depth = srcspec.full_depth;
dstspec.full_x = 0;
dstspec.full_y = 0;
dstspec.full_z = 0;
dstspec.full_width = dstspec.width;
dstspec.full_height = dstspec.height;
dstspec.full_depth = dstspec.depth;
}
if (orig_was_overscan)
configspec.attribute ("wrapmodes", "black,black");
if ((dstspec.x < 0 || dstspec.y < 0 || dstspec.z < 0) &&
(out && !out->supports("negativeorigin"))) {
// User passed negative origin but the output format doesn't
// support it. Try to salvage the situation by shifting the
// image into the positive range.
if (dstspec.x < 0) {
dstspec.full_x -= dstspec.x;
dstspec.x = 0;
}
if (dstspec.y < 0) {
dstspec.full_y -= dstspec.y;
dstspec.y = 0;
}
if (dstspec.z < 0) {
dstspec.full_z -= dstspec.z;
dstspec.z = 0;
}
}
// Make the output tiled, regardless of input
dstspec.tile_width = configspec.tile_width ? configspec.tile_width : 64;
dstspec.tile_height = configspec.tile_height ? configspec.tile_height : 64;
dstspec.tile_depth = configspec.tile_depth ? configspec.tile_depth : 1;
// Try to force zip (still can be overriden by configspec
dstspec.attribute ("compression", "zip");
// Always prefer contiguous channels, unless overridden by configspec
dstspec.attribute ("planarconfig", "contig");
// Default to black wrap mode, unless overridden by configspec
dstspec.attribute ("wrapmodes", "black,black");
if (configspec.get_int_attribute ("maketx:ignore_unassoc"))
dstspec.erase_attribute ("oiio:UnassociatedAlpha");
// Put a DateTime in the out file, either now, or matching the date
// stamp of the input file (if update mode).
time_t date;
if (updatemode)
date = in_time; // update mode: use the time stamp of the input
else
time (&date); // not update: get the time now
dstspec.attribute ("DateTime", datestring(date));
std::string cmdline = configspec.get_string_attribute ("maketx:full_command_line");
if (! cmdline.empty()) {
// Append command to image history
std::string history = dstspec.get_string_attribute ("Exif:ImageHistory");
if (history.length() && ! Strutil::iends_with (history, "\n"))
history += std::string("\n");
history += cmdline;
dstspec.attribute ("Exif:ImageHistory", history);
}
bool prman_metadata = configspec.get_int_attribute ("maketx:prman_metadata");
if (shadowmode) {
dstspec.attribute ("textureformat", "Shadow");
if (prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Shadow");
} else if (envlatlmode) {
dstspec.attribute ("textureformat", "LatLong Environment");
configspec.attribute ("wrapmodes", "periodic,clamp");
if (prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Latlong Environment");
} else {
dstspec.attribute ("textureformat", "Plain Texture");
if (prman_metadata)
dstspec.attribute ("PixarTextureFormat", "Plain Texture");
}
// FIXME -- should we allow tile sizes to reduce if the image is
// smaller than the tile size? And when we do, should we also try
// to make it bigger in the other direction to make the total tile
// size more constant?
// If --checknan was used and it's a floating point image, check for
// nonfinite (NaN or Inf) values and abort if they are found.
if (configspec.get_int_attribute("maketx:checknan") &&
(srcspec.format.basetype == TypeDesc::FLOAT ||
srcspec.format.basetype == TypeDesc::HALF ||
srcspec.format.basetype == TypeDesc::DOUBLE)) {
int found_nonfinite = 0;
ImageBufAlgo::parallel_image (boost::bind(check_nan_block, &src, _1, boost::ref(found_nonfinite)),
OIIO::get_roi(dstspec));
if (found_nonfinite) {
if (found_nonfinite > 3)
outstream << "maketx ERROR: ...and Nan/Inf at "
<< (found_nonfinite-3) << " other pixels\n";
return false;
}
}
// Fix nans/infs (if requested
ImageBufAlgo::NonFiniteFixMode fixmode = ImageBufAlgo::NONFINITE_NONE;
std::string fixnan = configspec.get_string_attribute("maketx:fixnan");
if (fixnan.empty() || fixnan == "none") { }
else if (fixnan == "black") { fixmode = ImageBufAlgo::NONFINITE_BLACK; }
else if (fixnan == "box3") { fixmode = ImageBufAlgo::NONFINITE_BOX3; }
else {
outstream << "maketx ERROR: Unknown --fixnan mode " << " fixnan\n";
return false;
}
int pixelsFixed = 0;
if (!ImageBufAlgo::fixNonFinite (src, src, fixmode, &pixelsFixed)) {
outstream << "maketx ERROR: Error fixing nans/infs.\n";
return false;
}
if (verbose && pixelsFixed>0) {
outstream << " Warning: " << pixelsFixed << " nan/inf pixels fixed.\n";
}
// Color convert the pixels, if needed, in place. If a color
// conversion is required we will promote the src to floating point
// (or there wont be enough precision potentially). Also,
// independently color convert the constant color metadata
ImageBuf * ccSrc = &src; // Ptr to cc'd src image
ImageBuf colorBuffer;
std::string incolorspace = configspec.get_string_attribute ("incolorspace");
std::string outcolorspace = configspec.get_string_attribute ("outcolorspace");
if (!incolorspace.empty() && !outcolorspace.empty() && incolorspace != outcolorspace) {
if (src.spec().format != TypeDesc::FLOAT) {
ImageSpec floatSpec = src.spec();
floatSpec.set_format(TypeDesc::FLOAT);
colorBuffer.reset("bitdepth promoted", floatSpec);
ccSrc = &colorBuffer;
}
Timer colorconverttimer;
ColorConfig colorconfig;
if (verbose) {
outstream << " Converting from colorspace " << incolorspace
<< " to colorspace " << outcolorspace << std::endl;
}
if (colorconfig.error()) {
outstream << "Error Creating ColorConfig\n";
outstream << colorconfig.geterror() << std::endl;
return false;
}
ColorProcessor * processor = colorconfig.createColorProcessor (
incolorspace.c_str(), outcolorspace.c_str());
if (!processor || colorconfig.error()) {
outstream << "Error Creating Color Processor." << std::endl;
outstream << colorconfig.geterror() << std::endl;
return false;
}
bool unpremult = configspec.get_int_attribute ("maketx:unpremult");
if (unpremult && verbose)
outstream << " Unpremulting image..." << std::endl;
if (!ImageBufAlgo::colorconvert (*ccSrc, src, processor, unpremult)) {
outstream << "Error applying color conversion to image.\n";
return false;
}
if (isConstantColor) {
if (!ImageBufAlgo::colorconvert (&constantColor[0],
static_cast<int>(constantColor.size()), processor, unpremult)) {
outstream << "Error applying color conversion to constant color.\n";
return false;
}
}
ColorConfig::deleteColorProcessor(processor);
processor = NULL;
stat_colorconverttime += colorconverttimer();
}
// Force float for the sake of the ImageBuf math
dstspec.set_format (TypeDesc::FLOAT);
// Handle resize to power of two, if called for
if (configspec.get_int_attribute("maketx:resize") && ! shadowmode) {
dstspec.width = pow2roundup (dstspec.width);
dstspec.height = pow2roundup (dstspec.height);
dstspec.full_width = dstspec.width;
dstspec.full_height = dstspec.height;
}
bool do_resize = false;
// Resize if we're up-resing for pow2
if (dstspec.width != srcspec.width || dstspec.height != srcspec.height ||
dstspec.full_depth != srcspec.full_depth)
do_resize = true;
// resize if the original was a crop
if (orig_was_crop)
do_resize = true;
// resize if we're converting from non-border sampling to border sampling
// (converting TO an OpenEXR environment map).
if (envlatlmode &&
(Strutil::iequals(configspec.get_string_attribute("maketx:fileformatname"),"openexr") ||
Strutil::iends_with(outputfilename,".exr")))
do_resize = true;
if (do_resize && orig_was_overscan &&
out && !out->supports("displaywindow")) {
outstream << "maketx ERROR: format " << out->format_name()
<< " does not support separate display windows,\n"
<< " which is necessary when combining resizing"
<< " and an input image with overscan.";
return false;
}
std::string filtername = configspec.get_string_attribute ("maketx:filtername", "box");
Filter2D *filter = setup_filter (filtername);
if (! filter) {
outstream << "maketx ERROR: could not make filter '" << filtername << "\n";
return false;
}
Timer resizetimer;
ImageBuf dst ("temp", dstspec);
ImageBuf *toplevel = &dst; // Ptr to top level of mipmap
if (! do_resize) {
// Don't need to resize
if (dstspec.format == ccSrc->spec().format) {
// Even more special case, no format change -- just use
// the original copy.
toplevel = ccSrc;
} else {
ImageBufAlgo::parallel_image (boost::bind(copy_block,&dst,ccSrc,_1),
OIIO::get_roi(dstspec));
}
} else {
// Resize
if (verbose)
outstream << " Resizing image to " << dstspec.width
<< " x " << dstspec.height << std::endl;
if (filtername == "box" && filter->width() == 1.0f)
ImageBufAlgo::parallel_image (boost::bind(resize_block, &dst, ccSrc, _1, envlatlmode),
OIIO::get_roi(dstspec));
else
ImageBufAlgo::parallel_image (boost::bind(resize_block_HQ, &dst, ccSrc, _1, filter),
OIIO::get_roi(dstspec));
}
stat_resizetime += resizetimer();
// Update the toplevel ImageDescription with the sha1 pixel hash and constant color
std::string desc = dstspec.get_string_attribute ("ImageDescription");
bool updatedDesc = false;
// Eliminate any SHA-1 or ConstantColor hints in the ImageDescription.
if (desc.size()) {
desc = boost::regex_replace (desc, boost::regex("SHA-1=[[:xdigit:]]*[ ]*"), "");
static const char *fp_number_pattern =
"([+-]?((?:(?:[[:digit:]]*\\.)?[[:digit:]]+(?:[eE][+-]?[[:digit:]]+)?)))";
const std::string color_pattern =
std::string ("ConstantColor=(\\[?") + fp_number_pattern + ",?)+\\]?[ ]*";
desc = boost::regex_replace (desc, boost::regex(color_pattern), "");
updatedDesc = true;
}
// The hash is only computed for the top mipmap level of pixel data.
// Thus, any additional information that will effect the lower levels
// (such as filtering information) needs to be manually added into the
// hash.
std::ostringstream addlHashData;
addlHashData << filter->name() << " ";
addlHashData << filter->width() << " ";
std::string hash_digest = ImageBufAlgo::computePixelHashSHA1 (*toplevel,
addlHashData.str());
if (hash_digest.length()) {
if (desc.length())
desc += " ";
desc += "SHA-1=";
desc += hash_digest;
if (verbose)
outstream << " SHA-1: " << hash_digest << std::endl;
updatedDesc = true;
dstspec.attribute ("oiio:SHA-1", hash_digest);
}
if (isConstantColor) {
std::ostringstream os; // Emulate a JSON array
os << "[";
for (unsigned int i=0; i<constantColor.size(); ++i) {
if (i!=0) os << ",";
os << constantColor[i];
}
os << "]";
if (desc.length())
desc += " ";
desc += "ConstantColor=";
desc += os.str();
if (verbose)
outstream << " ConstantColor: " << os.str() << std::endl;
updatedDesc = true;
dstspec.attribute ("oiio:ConstantColor", os.str());
}
if (updatedDesc) {
dstspec.attribute ("ImageDescription", desc);
}
if (configspec.get_float_attribute("fovcot") == 0.0f)
configspec.attribute("fovcot", float(srcspec.full_width) /
float(srcspec.full_height));
maketx_merge_spec (dstspec, configspec);
// Write out, and compute, the mipmap levels for the speicifed image
bool nomipmap = configspec.get_int_attribute ("maketx:nomipmap");
bool ok = write_mipmap (mode, *toplevel, dstspec, outputfilename,
out, out_dataformat, !shadowmode && !nomipmap,
filter, configspec, outstream,
stat_writetime, stat_miptime);
delete out; // don't need it any more
// If using update mode, stamp the output file with a modification time
// matching that of the input file.
if (ok && updatemode)
Filesystem::last_write_time (outputfilename, in_time);
Filter2D::destroy (filter);
if (verbose || configspec.get_int_attribute("maketx:stats")) {
double all = alltime();
outstream << Strutil::format ("maketx run time (seconds): %5.2f\n", all);;
outstream << Strutil::format (" file read: %5.2f\n", stat_readtime);
outstream << Strutil::format (" file write: %5.2f\n", stat_writetime);
outstream << Strutil::format (" initial resize: %5.2f\n", stat_resizetime);
outstream << Strutil::format (" mip computation: %5.2f\n", stat_miptime);
outstream << Strutil::format (" color convert: %5.2f\n", stat_colorconverttime);
outstream << Strutil::format (" unaccounted: %5.2f\n",
all-stat_readtime-stat_writetime-stat_resizetime-stat_miptime);
size_t kb = Sysutil::memory_used(true) / 1024;
outstream << Strutil::format ("maketx memory used: %5.1f MB\n",
(double)kb/1024.0);
}
return ok;
}
