int
main (int argc, char *argv[])
{
Timer alltimer;
ImageSpec configspec;
getargs (argc, argv, configspec);
OIIO::attribute ("threads", nthreads);
// N.B. This will apply to the default IC that any ImageBuf's get.
ImageCache *ic = ImageCache::create (); // get the shared one
ic->attribute ("forcefloat", 1); // Force float upon read
ic->attribute ("max_memory_MB", 1024.0); // 1 GB cache
ImageBufAlgo::MakeTextureMode mode = ImageBufAlgo::MakeTxTexture;
if (shadowmode)
mode = ImageBufAlgo::MakeTxShadow;
if (envlatlmode)
mode = ImageBufAlgo::MakeTxEnvLatl;
if (lightprobemode)
mode = ImageBufAlgo::MakeTxEnvLatlFromLightProbe;
bool ok = ImageBufAlgo::make_texture (mode, filenames[0],
outputfilename, configspec,
&std::cout);
if (stats)
std::cout << "\n" << ic->getstats();
return ok ? 0 : EXIT_FAILURE;
}
int
main (int argc, char *argv[])
{
Timer alltimer;
getargs (argc, argv);
if (stats) {
ImageCache *ic = ImageCache::create (); // get the shared one
ic->attribute ("forcefloat", 1); // Force float upon read
ic->attribute ("max_memory_MB", 1024.0); // 1 GB cache
// N.B. This will apply to the default IC that any ImageBuf's get.
}
if (mipmapmode) {
make_texturemap ("texture map");
} else if (shadowmode) {
make_texturemap ("shadow map");
} else if (shadowcubemode) {
std::cerr << "Shadow cubes currently unsupported\n";
} else if (volshadowmode) {
std::cerr << "Volume shadows currently unsupported\n";
} else if (envlatlmode) {
make_texturemap ("latlong environment map");
} else if (envcubemode) {
std::cerr << "Environment cubes currently unsupported\n";
} else if (lightprobemode) {
std::cerr << "Light probes currently unsupported\n";
} else if (vertcrossmode) {
std::cerr << "Vertcross currently unsupported\n";
} else if (latl2envcubemode) {
std::cerr << "Latlong->cube conversion currently unsupported\n";
}
if (verbose || stats) {
std::cout << "maketx Runtime statistics (seconds):\n";
double alltime = alltimer();
std::cout << Strutil::format (" total runtime: %5.2f\n", alltime);
std::cout << Strutil::format (" file read: %5.2f\n", stat_readtime);
std::cout << Strutil::format (" file write: %5.2f\n", stat_writetime);
std::cout << Strutil::format (" initial resize: %5.2f\n", stat_resizetime);
std::cout << Strutil::format (" mip computation: %5.2f\n", stat_miptime);
std::cout << Strutil::format (" unaccounted: %5.2f\n",
alltime-stat_readtime-stat_writetime-stat_resizetime-stat_miptime);
size_t kb = Sysutil::memory_used(true) / 1024;
std::cout << Strutil::format ("maketx memory used: %5.1f MB\n",
(double)kb/1024.0);
}
Filter2D::destroy (filter);
if (stats) {
ImageCache *ic = ImageCache::create (); // get the shared one
std::cout << "\n" << ic->getstats();
}
return 0;
}
int
main (int argc, char *argv[])
{
getargs (argc, argv);
if (! foreground_mode)
Sysutil::put_in_background (argc, argv);
// LG
// Q_INIT_RESOURCE(iv);
QApplication app(argc, argv);
ImageViewer *mainWin = new ImageViewer;
mainWin->show();
// Set up the imagecache with parameters that make sense for iv
ImageCache *imagecache = ImageCache::create (true);
imagecache->attribute ("autotile", 256);
// Make sure we are the top window with the focus.
mainWin->raise ();
mainWin->activateWindow ();
// Add the images
BOOST_FOREACH (const std::string &s, filenames) {
mainWin->add_image (s);
}
int
main (int argc, char *argv[])
{
Timer alltimer;
// Globally force classic "C" locale, and turn off all formatting
// internationalization, for the entire maketx application.
std::locale::global (std::locale::classic());
ImageSpec configspec;
Filesystem::convert_native_arguments (argc, (const char **)argv);
getargs (argc, argv, configspec);
OIIO::attribute ("threads", nthreads);
// N.B. This will apply to the default IC that any ImageBuf's get.
ImageCache *ic = ImageCache::create (); // get the shared one
ic->attribute ("forcefloat", 1); // Force float upon read
ic->attribute ("max_memory_MB", 1024.0); // 1 GB cache
ImageBufAlgo::MakeTextureMode mode = ImageBufAlgo::MakeTxTexture;
if (shadowmode)
mode = ImageBufAlgo::MakeTxShadow;
if (envlatlmode)
mode = ImageBufAlgo::MakeTxEnvLatl;
if (lightprobemode)
mode = ImageBufAlgo::MakeTxEnvLatlFromLightProbe;
if (bumpslopesmode)
mode = ImageBufAlgo::MakeTxBumpWithSlopes;
bool ok = ImageBufAlgo::make_texture (mode, filenames[0],
outputfilename, configspec,
&std::cout);
if (runstats)
std::cout << "\n" << ic->getstats();
return ok ? 0 : EXIT_FAILURE;
}
int
main (int argc, char *argv[])
{
Filesystem::convert_native_arguments (argc, (const char **)argv);
getargs (argc, argv);
if (! quiet)
std::cout << "Comparing \"" << filenames[0]
<< "\" and \"" << filenames[1] << "\"\n";
// Create a private ImageCache so we can customize its cache size
// and instruct it store everything internally as floats.
ImageCache *imagecache = ImageCache::create (true);
imagecache->attribute ("forcefloat", 1);
if (sizeof(void *) == 4) // 32 bit or 64?
imagecache->attribute ("max_memory_MB", 512.0);
else
imagecache->attribute ("max_memory_MB", 2048.0);
imagecache->attribute ("autotile", 256);
// force a full diff, even for files tagged with the same
// fingerprint, just in case some mistake has been made.
imagecache->attribute ("deduplicate", 0);
ImageBuf img0, img1;
if (! read_input (filenames[0], img0, imagecache) ||
! read_input (filenames[1], img1, imagecache))
return ErrFile;
// ImageSpec spec0 = img0.spec(); // stash it
int ret = ErrOK;
for (int subimage = 0; subimage < img0.nsubimages(); ++subimage) {
if (subimage > 0 && !compareall)
break;
if (subimage >= img1.nsubimages())
break;
if (! read_input (filenames[0], img0, imagecache, subimage) ||
! read_input (filenames[1], img1, imagecache, subimage)) {
std::cerr << "Failed to read subimage " << subimage << "\n";
return ErrFile;
}
if (img0.nmiplevels() != img1.nmiplevels()) {
if (! quiet)
std::cout << "Files do not match in their number of MIPmap levels\n";
}
for (int m = 0; m < img0.nmiplevels(); ++m) {
if (m > 0 && !compareall)
break;
if (m > 0 && img0.nmiplevels() != img1.nmiplevels()) {
std::cerr << "Files do not match in their number of MIPmap levels\n";
ret = ErrDifferentSize;
break;
}
if (! read_input (filenames[0], img0, imagecache, subimage, m) ||
! read_input (filenames[1], img1, imagecache, subimage, m))
return ErrFile;
if (img0.deep() != img1.deep()) {
std::cerr << "One image contains deep data, the other does not\n";
ret = ErrDifferentSize;
break;
}
int npels = img0.spec().width * img0.spec().height * img0.spec().depth;
if (npels == 0)
npels = 1; // Avoid divide by zero for 0x0 images
ASSERT (img0.spec().format == TypeDesc::FLOAT);
// Compare the two images.
//
ImageBufAlgo::CompareResults cr;
ImageBufAlgo::compare (img0, img1, failthresh, warnthresh, cr);
int yee_failures = 0;
if (perceptual && ! img0.deep()) {
ImageBufAlgo::CompareResults cr;
yee_failures = ImageBufAlgo::compare_Yee (img0, img1, cr);
}
if (cr.nfail > (failpercent/100.0 * npels) || cr.maxerror > hardfail ||
yee_failures > (failpercent/100.0 * npels)) {
ret = ErrFail;
} else if (cr.nwarn > (warnpercent/100.0 * npels) || cr.maxerror > hardwarn) {
if (ret != ErrFail)
ret = ErrWarn;
}
// Print the report
//
if (verbose || (ret != ErrOK && !quiet)) {
if (compareall)
print_subimage (img0, subimage, m);
std::cout << " Mean error = ";
safe_double_print (cr.meanerror);
std::cout << " RMS error = ";
safe_double_print (cr.rms_error);
std::cout << " Peak SNR = ";
safe_double_print (cr.PSNR);
std::cout << " Max error = " << cr.maxerror;
if (cr.maxerror != 0) {
std::cout << " @ (" << cr.maxx << ", " << cr.maxy;
if (img0.spec().depth > 1)
std::cout << ", " << cr.maxz;
if (cr.maxc < (int)img0.spec().channelnames.size())
std::cout << ", " << img0.spec().channelnames[cr.maxc] << ')';
else if (cr.maxc < (int)img1.spec().channelnames.size())
std::cout << ", " << img1.spec().channelnames[cr.maxc] << ')';
else
std::cout << ", channel " << cr.maxc << ')';
}
std::cout << "\n";
// when Visual Studio is used float values in scientific foramt are
// printed with three digit exponent. We change this behaviour to fit
// Linux way
#ifdef _MSC_VER
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
std::streamsize precis = std::cout.precision();
std::cout << " " << cr.nwarn << " pixels ("
<< std::setprecision(3) << (100.0*cr.nwarn / npels)
<< std::setprecision(precis) << "%) over " << warnthresh << "\n";
std::cout << " " << cr.nfail << " pixels ("
<< std::setprecision(3) << (100.0*cr.nfail / npels)
<< std::setprecision(precis) << "%) over " << failthresh << "\n";
if (perceptual)
std::cout << " " << yee_failures << " pixels ("
<< std::setprecision(3) << (100.0*yee_failures / npels)
<< std::setprecision(precis)
<< "%) failed the perceptual test\n";
}
// If the user requested that a difference image be output,
// do that. N.B. we only do this for the first subimage
// right now, because ImageBuf doesn't really know how to
// write subimages.
if (diffimage.size() && (cr.maxerror != 0 || !outdiffonly)) {
ImageBuf diff;
if (diffabs)
ImageBufAlgo::absdiff (diff, img0, img1);
else
ImageBufAlgo::sub (diff, img0, img1);
if (diffscale != 1.0f)
ImageBufAlgo::mul (diff, diff, diffscale);
diff.write (diffimage);
// Clear diff image name so we only save the first
// non-matching subimage.
diffimage = "";
}
}
}
if (compareall && img0.nsubimages() != img1.nsubimages()) {
if (! quiet)
std::cerr << "Images had differing numbers of subimages ("
<< img0.nsubimages() << " vs " << img1.nsubimages() << ")\n";
ret = ErrFail;
}
if (!compareall && (img0.nsubimages() > 1 || img1.nsubimages() > 1)) {
if (! quiet)
std::cout << "Only compared the first subimage (of "
<< img0.nsubimages() << " and " << img1.nsubimages()
<< ", respectively)\n";
}
if (ret == ErrOK) {
if (! quiet)
std::cout << "PASS\n";
}
else if (ret == ErrWarn) {
if (! quiet)
std::cout << "WARNING\n";
}
else if (ret) {
if (quiet)
std::cerr << "FAILURE\n";
else
std::cout << "FAILURE\n";
}
imagecache->invalidate_all (true);
ImageCache::destroy (imagecache);
return ret;
}
int
main (int argc, char *argv[])
{
getargs (argc, argv);
std::cout << "Comparing \"" << filenames[0]
<< "\" and \"" << filenames[1] << "\"\n";
// Create a private ImageCache so we can customize its cache size
// and instruct it store everything internally as floats.
ImageCache *imagecache = ImageCache::create (true);
imagecache->attribute ("forcefloat", 1);
if (sizeof(void *) == 4) // 32 bit or 64?
imagecache->attribute ("max_memory_MB", 512.0);
else
imagecache->attribute ("max_memory_MB", 2048.0);
imagecache->attribute ("autotile", 256);
#ifdef DEBUG
imagecache->attribute ("statistics:level", 2);
#endif
ImageBuf img0, img1;
if (! read_input (filenames[0], img0, imagecache) ||
! read_input (filenames[1], img1, imagecache))
return ErrFile;
// ImageSpec spec0 = img0.spec(); // stash it
int ret = ErrOK;
for (int subimage = 0; subimage < img0.nsubimages(); ++subimage) {
if (subimage > 0 && !compareall)
break;
if (subimage >= img1.nsubimages())
break;
if (compareall) {
std::cout << "Subimage " << subimage << ": ";
std::cout << img0.spec().width << " x " << img0.spec().height;
if (img0.spec().depth > 1)
std::cout << " x " << img0.spec().depth;
std::cout << ", " << img0.spec().nchannels << " channel\n";
}
if (! read_input (filenames[0], img0, imagecache, subimage) ||
! read_input (filenames[1], img1, imagecache, subimage))
return ErrFile;
if (img0.nmiplevels() != img1.nmiplevels()) {
std::cout << "Files do not match in their number of MIPmap levels\n";
}
for (int m = 0; m < img0.nmiplevels(); ++m) {
if (m > 0 && !compareall)
break;
if (m > 0 && img0.nmiplevels() != img1.nmiplevels()) {
std::cout << "Files do not match in their number of MIPmap levels\n";
ret = ErrDifferentSize;
break;
}
if (! read_input (filenames[0], img0, imagecache, subimage, m) ||
! read_input (filenames[1], img1, imagecache, subimage, m))
return ErrFile;
if (compareall && img0.nmiplevels() > 1) {
std::cout << " MIP level " << m << ": ";
std::cout << img0.spec().width << " x " << img0.spec().height;
if (img0.spec().depth > 1)
std::cout << " x " << img0.spec().depth;
std::cout << ", " << img0.spec().nchannels << " channel\n";
}
// Compare the dimensions of the images. Fail if they
// aren't the same resolution and number of channels. No
// problem, though, if they aren't the same data type.
if (! same_size (img0, img1)) {
std::cout << "Images do not match in size: ";
std::cout << "(" << img0.spec().width << "x" << img0.spec().height;
if (img0.spec().depth > 1)
std::cout << "x" << img0.spec().depth;
std::cout << "x" << img0.spec().nchannels << ")";
std::cout << " versus ";
std::cout << "(" << img1.spec().width << "x" << img1.spec().height;
if (img1.spec().depth > 1)
std::cout << "x" << img1.spec().depth;
std::cout << "x" << img1.spec().nchannels << ")\n";
ret = ErrDifferentSize;
break;
}
int npels = img0.spec().width * img0.spec().height * img0.spec().depth;
ASSERT (img0.spec().format == TypeDesc::FLOAT);
// Compare the two images.
//
ImageBufAlgo::CompareResults cr;
ImageBufAlgo::compare (img0, img1, failthresh, warnthresh, cr);
int yee_failures = 0;
if (perceptual)
yee_failures = ImageBufAlgo::compare_Yee (img0, img1);
// Print the report
//
std::cout << " Mean error = ";
safe_double_print (cr.meanerror);
std::cout << " RMS error = ";
safe_double_print (cr.rms_error);
std::cout << " Peak SNR = ";
safe_double_print (cr.PSNR);
std::cout << " Max error = " << cr.maxerror;
if (cr.maxerror != 0) {
std::cout << " @ (" << cr.maxx << ", " << cr.maxy;
if (img0.spec().depth > 1)
std::cout << ", " << cr.maxz;
std::cout << ", " << img0.spec().channelnames[cr.maxc] << ')';
}
std::cout << "\n";
// when Visual Studio is used float values in scientific foramt are
// printed with three digit exponent. We change this behaviour to fit
// Linux way
#ifdef _MSC_VER
_set_output_format(_TWO_DIGIT_EXPONENT);
#endif
int precis = std::cout.precision();
std::cout << " " << cr.nwarn << " pixels ("
<< std::setprecision(3) << (100.0*cr.nwarn / npels)
<< std::setprecision(precis) << "%) over " << warnthresh << "\n";
std::cout << " " << cr.nfail << " pixels ("
<< std::setprecision(3) << (100.0*cr.nfail / npels)
<< std::setprecision(precis) << "%) over " << failthresh << "\n";
if (perceptual)
std::cout << " " << yee_failures << " pixels ("
<< std::setprecision(3) << (100.0*yee_failures / npels)
<< std::setprecision(precis)
<< "%) failed the perceptual test\n";
if (cr.nfail > (failpercent/100.0 * npels) || cr.maxerror > hardfail ||
yee_failures > (failpercent/100.0 * npels)) {
ret = ErrFail;
} else if (cr.nwarn > (warnpercent/100.0 * npels) || cr.maxerror > hardwarn) {
if (ret != ErrFail)
ret = ErrWarn;
}
// If the user requested that a difference image be output,
// do that. N.B. we only do this for the first subimage
// right now, because ImageBuf doesn't really know how to
// write subimages.
if (diffimage.size() && (cr.maxerror != 0 || !outdiffonly)) {
ImageBuf diff (diffimage, img0.spec());
ImageBuf::ConstIterator<float,float> pix0 (img0);
ImageBuf::ConstIterator<float,float> pix1 (img1);
ImageBuf::Iterator<float,float> pixdiff (diff);
// Subtract the second image from the first. At which
// time we no longer need the second image, so free it.
if (diffabs) {
for ( ; pix0.valid(); ++pix0) {
pix1.pos (pix0.x(), pix0.y()); // ensure alignment
pixdiff.pos (pix0.x(), pix0.y());
for (int c = 0; c < img0.nchannels(); ++c)
pixdiff[c] = diffscale * fabsf (pix0[c] - pix1[c]);
}
} else {
for ( ; pix0.valid(); ++pix0) {
pix1.pos (pix0.x(), pix0.y()); // ensure alignment
pixdiff.pos (pix0.x(), pix0.y());
for (int c = 0; c < img0.spec().nchannels; ++c)
pixdiff[c] = diffscale * (pix0[c] - pix1[c]);
}
}
diff.save (diffimage);
// Clear diff image name so we only save the first
// non-matching subimage.
diffimage = "";
}
}
}
if (compareall && img0.nsubimages() != img1.nsubimages()) {
std::cout << "Images had differing numbers of subimages ("
<< img0.nsubimages() << " vs " << img1.nsubimages() << ")\n";
ret = ErrFail;
}
if (!compareall && (img0.nsubimages() > 1 || img1.nsubimages() > 1)) {
std::cout << "Only compared the first subimage (of "
<< img0.nsubimages() << " and " << img1.nsubimages()
<< ", respectively)\n";
}
if (ret == ErrOK)
std::cout << "PASS\n";
else if (ret == ErrWarn)
std::cout << "WARNING\n";
else
std::cout << "FAILURE\n";
ImageCache::destroy (imagecache);
return ret;
}
static void
getargs (int argc, char *argv[], ImageSpec &configspec)
{
bool help = false;
// Basic runtime options
std::string dataformatname = "";
std::string fileformatname = "";
std::vector<std::string> mipimages;
int tile[3] = { 64, 64, 1 }; // FIXME if we ever support volume MIPmaps
std::string compression = "zip";
bool updatemode = false;
bool checknan = false;
std::string fixnan; // none, black, box3
bool set_full_to_pixels = false;
bool do_highlight_compensation = false;
std::string filtername;
// Options controlling file metadata or mipmap creation
float fovcot = 0.0f;
std::string wrap = "black";
std::string swrap;
std::string twrap;
bool doresize = false;
Imath::M44f Mcam(0.0f), Mscr(0.0f); // Initialize to 0
bool separate = false;
bool nomipmap = false;
bool prman_metadata = false;
bool constant_color_detect = false;
bool monochrome_detect = false;
bool opaque_detect = false;
bool compute_average = true;
int nchannels = -1;
bool prman = false;
bool oiio = false;
bool ignore_unassoc = false; // ignore unassociated alpha tags
bool unpremult = false;
bool sansattrib = false;
float sharpen = 0.0f;
std::string incolorspace;
std::string outcolorspace;
std::string colorconfigname;
std::string channelnames;
std::vector<std::string> string_attrib_names, string_attrib_values;
std::vector<std::string> any_attrib_names, any_attrib_values;
filenames.clear();
ArgParse ap;
ap.options ("maketx -- convert images to tiled, MIP-mapped textures\n"
OIIO_INTRO_STRING "\n"
"Usage: maketx [options] file...",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"-o %s", &outputfilename, "Output filename",
"--threads %d", &nthreads, "Number of threads (default: #cores)",
"-u", &updatemode, "Update mode",
"--format %s", &fileformatname, "Specify output file format (default: guess from extension)",
"--nchannels %d", &nchannels, "Specify the number of output image channels.",
"--chnames %s", &channelnames, "Rename channels (comma-separated)",
"-d %s", &dataformatname, "Set the output data format to one of: "
"uint8, sint8, uint16, sint16, half, float",
"--tile %d %d", &tile[0], &tile[1], "Specify tile size",
"--separate", &separate, "Use planarconfig separate (default: contiguous)",
"--compression %s", &compression, "Set the compression method (default = zip, if possible)",
"--fovcot %f", &fovcot, "Override the frame aspect ratio. Default is width/height.",
"--wrap %s", &wrap, "Specify wrap mode (black, clamp, periodic, mirror)",
"--swrap %s", &swrap, "Specific s wrap mode separately",
"--twrap %s", &twrap, "Specific t wrap mode separately",
"--resize", &doresize, "Resize textures to power of 2 (default: no)",
"--noresize %!", &doresize, "Do not resize textures to power of 2 (deprecated)",
"--filter %s", &filtername, filter_help_string().c_str(),
"--hicomp", &do_highlight_compensation,
"Compress HDR range before resize, expand after.",
"--sharpen %f", &sharpen, "Sharpen MIP levels (default = 0.0 = no)",
"--nomipmap", &nomipmap, "Do not make multiple MIP-map levels",
"--checknan", &checknan, "Check for NaN/Inf values (abort if found)",
"--fixnan %s", &fixnan, "Attempt to fix NaN/Inf values in the image (options: none, black, box3)",
"--fullpixels", &set_full_to_pixels, "Set the 'full' image range to be the pixel data window",
"--Mcamera %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
&Mcam[0][0], &Mcam[0][1], &Mcam[0][2], &Mcam[0][3],
&Mcam[1][0], &Mcam[1][1], &Mcam[1][2], &Mcam[1][3],
&Mcam[2][0], &Mcam[2][1], &Mcam[2][2], &Mcam[2][3],
&Mcam[3][0], &Mcam[3][1], &Mcam[3][2], &Mcam[3][3],
"Set the camera matrix",
"--Mscreen %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
&Mscr[0][0], &Mscr[0][1], &Mscr[0][2], &Mscr[0][3],
&Mscr[1][0], &Mscr[1][1], &Mscr[1][2], &Mscr[1][3],
&Mscr[2][0], &Mscr[2][1], &Mscr[2][2], &Mscr[2][3],
&Mscr[3][0], &Mscr[3][1], &Mscr[3][2], &Mscr[3][3],
"Set the screen matrix",
"--prman-metadata", &prman_metadata, "Add prman specific metadata",
"--attrib %L %L", &any_attrib_names, &any_attrib_values, "Sets metadata attribute (name, value)",
"--sattrib %L %L", &string_attrib_names, &string_attrib_values, "Sets string metadata attribute (name, value)",
"--sansattrib", &sansattrib, "Write command line into Software & ImageHistory but remove --sattrib and --attrib options",
"--constant-color-detect", &constant_color_detect, "Create 1-tile textures from constant color inputs",
"--monochrome-detect", &monochrome_detect, "Create 1-channel textures from monochrome inputs",
"--opaque-detect", &opaque_detect, "Drop alpha channel that is always 1.0",
"--no-compute-average %!", &compute_average, "Don't compute and store average color",
"--ignore-unassoc", &ignore_unassoc, "Ignore unassociated alpha tags in input (don't autoconvert)",
"--runstats", &runstats, "Print runtime statistics",
"--stats", &runstats, "", // DEPRECATED 1.6
"--mipimage %L", &mipimages, "Specify an individual MIP level",
"<SEPARATOR>", "Basic modes (default is plain texture):",
"--shadow", &shadowmode, "Create shadow map",
"--envlatl", &envlatlmode, "Create lat/long environment map",
"--lightprobe", &lightprobemode, "Create lat/long environment map from a light probe",
"--bumpslopes", &bumpslopesmode, "Create a 6 channels bump-map with height, derivatives and square derivatives from an height or a normal map",
// "--envcube", &envcubemode, "Create cubic env map (file order: px, nx, py, ny, pz, nz) (UNIMP)",
"<SEPARATOR>", colortitle_help_string().c_str(),
"--colorconfig %s", &colorconfigname, "Explicitly specify an OCIO configuration file",
"--colorconvert %s %s", &incolorspace, &outcolorspace,
colorconvert_help_string().c_str(),
"--unpremult", &unpremult, "Unpremultiply before color conversion, then premultiply "
"after the color conversion. You'll probably want to use this flag "
"if your image contains an alpha channel.",
"<SEPARATOR>", "Configuration Presets",
"--prman", &prman, "Use PRMan-safe settings for tile size, planarconfig, and metadata.",
"--oiio", &oiio, "Use OIIO-optimized settings for tile size, planarconfig, metadata.",
NULL);
if (ap.parse (argc, (const char**)argv) < 0) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
exit (EXIT_FAILURE);
}
if (help) {
ap.usage ();
exit (EXIT_FAILURE);
}
if (filenames.empty()) {
ap.briefusage ();
std::cout << "\nFor detailed help: maketx --help\n";
exit (EXIT_SUCCESS);
}
int optionsum = ((int)shadowmode + (int)envlatlmode + (int)envcubemode +
(int)lightprobemode) + (int)bumpslopesmode;
if (optionsum > 1) {
std::cerr << "maketx ERROR: At most one of the following options may be set:\n"
<< "\t--shadow --envlatl --envcube --lightprobe\n";
exit (EXIT_FAILURE);
}
if (optionsum == 0)
mipmapmode = true;
if (prman && oiio) {
std::cerr << "maketx ERROR: '--prman' compatibility, and '--oiio' optimizations are mutually exclusive.\n";
std::cerr << "\tIf you'd like both prman and oiio compatibility, you should choose --prman\n";
std::cerr << "\t(at the expense of oiio-specific optimizations)\n";
exit (EXIT_FAILURE);
}
if (filenames.size() != 1) {
std::cerr << "maketx ERROR: requires exactly one input filename\n";
exit (EXIT_FAILURE);
}
// std::cout << "Converting " << filenames[0] << " to " << outputfilename << "\n";
// Figure out which data format we want for output
if (! dataformatname.empty()) {
if (dataformatname == "uint8")
configspec.format = TypeDesc::UINT8;
else if (dataformatname == "int8" || dataformatname == "sint8")
configspec.format = TypeDesc::INT8;
else if (dataformatname == "uint16")
configspec.format = TypeDesc::UINT16;
else if (dataformatname == "int16" || dataformatname == "sint16")
configspec.format = TypeDesc::INT16;
else if (dataformatname == "half")
configspec.format = TypeDesc::HALF;
else if (dataformatname == "float")
configspec.format = TypeDesc::FLOAT;
else if (dataformatname == "double")
configspec.format = TypeDesc::DOUBLE;
else {
std::cerr << "maketx ERROR: unknown data format \"" << dataformatname << "\"\n";
exit (EXIT_FAILURE);
}
}
configspec.tile_width = tile[0];
configspec.tile_height = tile[1];
configspec.tile_depth = tile[2];
configspec.attribute ("compression", compression);
if (fovcot != 0.0f)
configspec.attribute ("fovcot", fovcot);
configspec.attribute ("planarconfig", separate ? "separate" : "contig");
if (Mcam != Imath::M44f(0.0f))
configspec.attribute ("worldtocamera", TypeMatrix, &Mcam);
if (Mscr != Imath::M44f(0.0f))
configspec.attribute ("worldtoscreen", TypeMatrix, &Mscr);
std::string wrapmodes = (swrap.size() ? swrap : wrap) + ',' +
(twrap.size() ? twrap : wrap);
configspec.attribute ("wrapmodes", wrapmodes);
configspec.attribute ("maketx:verbose", verbose);
configspec.attribute ("maketx:runstats", runstats);
configspec.attribute ("maketx:resize", doresize);
configspec.attribute ("maketx:nomipmap", nomipmap);
configspec.attribute ("maketx:updatemode", updatemode);
configspec.attribute ("maketx:constant_color_detect", constant_color_detect);
configspec.attribute ("maketx:monochrome_detect", monochrome_detect);
configspec.attribute ("maketx:opaque_detect", opaque_detect);
configspec.attribute ("maketx:compute_average", compute_average);
configspec.attribute ("maketx:unpremult", unpremult);
configspec.attribute ("maketx:incolorspace", incolorspace);
configspec.attribute ("maketx:outcolorspace", outcolorspace);
configspec.attribute ("maketx:colorconfig", colorconfigname);
configspec.attribute ("maketx:checknan", checknan);
configspec.attribute ("maketx:fixnan", fixnan);
configspec.attribute ("maketx:set_full_to_pixels", set_full_to_pixels);
configspec.attribute ("maketx:highlightcomp", (int)do_highlight_compensation);
configspec.attribute ("maketx:sharpen", sharpen);
if (filtername.size())
configspec.attribute ("maketx:filtername", filtername);
configspec.attribute ("maketx:nchannels", nchannels);
configspec.attribute ("maketx:channelnames", channelnames);
if (fileformatname.size())
configspec.attribute ("maketx:fileformatname", fileformatname);
configspec.attribute ("maketx:prman_metadata", prman_metadata);
configspec.attribute ("maketx:oiio_options", oiio);
configspec.attribute ("maketx:prman_options", prman);
if (mipimages.size())
configspec.attribute ("maketx:mipimages", Strutil::join(mipimages,";"));
std::string cmdline = Strutil::format ("OpenImageIO %s : %s",
OIIO_VERSION_STRING,
command_line_string (argc, argv, sansattrib));
configspec.attribute ("Software", cmdline);
configspec.attribute ("maketx:full_command_line", cmdline);
// Add user-specified string attributes
for (size_t i = 0; i < string_attrib_names.size(); ++i) {
configspec.attribute (string_attrib_names[i], string_attrib_values[i]);
}
// Add user-specified "any" attributes -- try to deduce the type
for (size_t i = 0; i < any_attrib_names.size(); ++i) {
string_view s = any_attrib_values[i];
// Does it parse as an int (and nothing more?)
int ival;
if (Strutil::parse_int(s,ival)) {
Strutil::skip_whitespace(s);
if (! s.size()) {
configspec.attribute (any_attrib_names[i], ival);
continue;
}
}
s = any_attrib_values[i];
// Does it parse as a float (and nothing more?)
float fval;
if (Strutil::parse_float(s,fval)) {
Strutil::skip_whitespace(s);
if (! s.size()) {
configspec.attribute (any_attrib_names[i], fval);
continue;
}
}
// OK, treat it like a string
configspec.attribute (any_attrib_names[i], any_attrib_values[i]);
}
if (ignore_unassoc) {
configspec.attribute ("maketx:ignore_unassoc", (int)ignore_unassoc);
ImageCache *ic = ImageCache::create (); // get the shared one
ic->attribute ("unassociatedalpha", (int)ignore_unassoc);
}
}
