static void
getargs(int argc, char* argv[])
{
bool help = false;
ArgParse ap;
// clang-format off
ap.options(
"fmath_test\n" OIIO_INTRO_STRING "\n"
"Usage: fmath_test [options]",
// "%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose mode",
// "--threads %d", &numthreads,
// ustring::sprintf("Number of threads (default: %d)", numthreads).c_str(),
"--iterations %d", &iterations,
ustring::sprintf("Number of values to convert for benchmarks (default: %d)", iterations).c_str(),
"--trials %d", &ntrials, "Number of trials",
nullptr);
// clang-format on
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);
}
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("hash_test\n"
OIIO_INTRO_STRING "\n"
"Usage: hash_test [options]",
// "%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose mode",
"--iters %d", &iterations,
Strutil::format("Number of iterations (default: %d)", iterations).c_str(),
"--trials %d", &ntrials, "Number of trials",
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);
}
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("spin_rw_test\n"
OIIO_INTRO_STRING "\n"
"Usage: spin_rw_test [options]",
// "%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose mode",
"--threads %d", &numthreads,
ustring::format("Number of threads (default: %d)", numthreads).c_str(),
"--iters %d", &iterations,
ustring::format("Number of iterations (default: %d)", iterations).c_str(),
"--trials %d", &ntrials, "Number of trials",
"--rwratio %d", &read_write_ratio,
ustring::format("Reader::writer ratio (default: %d)", read_write_ratio).c_str(),
"--wedge", &wedge, "Do a wedge test",
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);
}
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("compute_test\n"
OIIO_INTRO_STRING "\n"
"Usage: compute_test [options]",
// "%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose mode",
"--threads %d", &numthreads,
ustring::format("Number of threads (default: %d)", numthreads).c_str(),
"--iterations %d", &iterations,
ustring::format("Number of iterations (default: %d)", iterations).c_str(),
"--trials %d", &ntrials, "Number of trials",
"--allgpus", &allgpus, "Run OpenCL tests on all devices, not just default",
"--wedge", &wedge, "Do a wedge test",
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);
}
}
static void
getargs (int argc, const char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("Usage: testtex [options] inputfile",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"-o %s", &output_filename, "Output test image",
"-d %s", &dataformatname, "Set the output data format to one of:"
"uint8, sint8, uint10, uint12, uint16, sint16, half, float, double",
"-res %d %d", &output_xres, &output_yres,
"Resolution of output test image",
"-iters %d", &iters,
"Iterations for time trials",
"--blur %f", &blur, "Add blur to texture lookup",
"--width %f", &width, "Multiply filter width of texture lookup",
"--fill %f", &fill, "Set fill value for missing channels",
"--wrap %s", &wrapmodes, "Set wrap mode (default, black, clamp, periodic, mirror, overscan)",
"--missing %f %f %f", &missing[0], &missing[1], &missing[2],
"Specify missing texture color",
"--autotile %d", &autotile, "Set auto-tile size for the image cache",
"--automip", &automip, "Set auto-MIPmap for the image cache",
"--blocksize %d", &blocksize, "Set blocksize (n x n) for batches",
"--handle", &use_handle, "Use texture handle rather than name lookup",
"--searchpath %s", &searchpath, "Search path for files",
"--nowarp", &nowarp, "Do not warp the image->texture mapping",
"--tube", &tube, "Make a tube projection",
"--cachesize %f", &cachesize, "Set cache size, in MB",
"--scale %f", &scalefactor, "Scale intensities",
"--maxfiles %d", &maxfiles, "Set maximum open files",
"--nountiled", &nountiled, "Reject untiled images",
"--nounmipped", &nounmipped, "Reject unmipped images",
"--ctr", &test_construction, "Test TextureOpt construction time",
"--gettexels", &test_gettexels, "Test TextureSystem::get_texels",
"--getimagespec", &test_getimagespec, "Test TextureSystem::get_imagespec",
"--offset %f %f %f", &offset[0], &offset[1], &offset[2], "Offset texture coordinates",
"--scalest %f %f", &sscale, &tscale, "Scale texture lookups (s, t)",
"--graytorgb", &gray_to_rgb, "Convert gratscale textures to RGB",
"--resetstats", &resetstats, "Print and reset statistics on each iteration",
NULL);
if (ap.parse (argc, argv) < 0) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
exit (EXIT_FAILURE);
}
if (help) {
ap.usage ();
exit (EXIT_FAILURE);
}
if (filenames.size() < 1) {
std::cerr << "testtex: Must have at least one input file\n";
ap.usage();
exit (EXIT_FAILURE);
}
}
int main(int argc, const char **argv)
{
util_logging_init(argv[0]);
path_init();
/* device types */
string devicelist = "";
string devicename = "cpu";
bool list = false, debug = false;
int threads = 0, verbosity = 1;
vector<DeviceType>& types = Device::available_types();
foreach(DeviceType type, types) {
if(devicelist != "")
devicelist += ", ";
devicelist += Device::string_from_type(type);
}
/* parse options */
ArgParse ap;
ap.options ("Usage: cycles_server [options]",
"--device %s", &devicename, ("Devices to use: " + devicelist).c_str(),
"--list-devices", &list, "List information about all available devices",
"--threads %d", &threads, "Number of threads to use for CPU device",
#ifdef WITH_CYCLES_LOGGING
"--debug", &debug, "Enable debug logging",
"--verbose %d", &verbosity, "Set verbosity of the logger",
#endif
NULL);
if(ap.parse(argc, argv) < 0) {
fprintf(stderr, "%s\n", ap.geterror().c_str());
ap.usage();
exit(EXIT_FAILURE);
}
if(debug) {
util_logging_start();
util_logging_verbosity_set(verbosity);
}
if(list) {
vector<DeviceInfo>& devices = Device::available_devices();
printf("Devices:\n");
foreach(DeviceInfo& info, devices) {
printf(" %s%s\n",
info.description.c_str(),
(info.display_device)? " (display)": "");
}
exit(EXIT_SUCCESS);
}
static void
getargs (int argc, const char *argv[])
{
static bool help = false;
ArgParse ap;
ap.options ("Usage: testshade [options] shader...",
"%*", add_shader, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose messages",
"--debug", &debug, "Lots of debugging info",
"--stats", &stats, "Print run statistics",
"-g %d %d", &xres, &yres, "Make an X x Y grid of shading points",
"-o %L %L", &outputvars, &outputfiles,
"Output (variable, filename)",
"-od %s", &dataformatname, "Set the output data format to one of:\n"
"\t\t\t\tuint8, half, float",
"--layer %s", &layername, "Set next layer name",
"--fparam %L %L",
&fparams, &fparams,
"Add a float param (args: name value)",
"--iparam %L %L",
&iparams, &iparams,
"Add an integer param (args: name value)",
"--vparam %L %L %L %L",
&vparams, &vparams, &vparams, &vparams,
"Add a vector or color param (args: name x y z)",
"--sparam %L %L",
&sparams, &sparams,
"Add a string param (args: name value)",
"--connect %L %L %L %L",
&connections, &connections, &connections, &connections,
"Connect fromlayer fromoutput tolayer toinput",
"--raytype %s", &raytype, "Set the raytype",
"--iters %d", &iters, "Number of iterations",
"-O0", &O0, "Do no runtime shader optimization",
"-O1", &O1, "Do a little runtime shader optimization",
"-O2", &O2, "Do lots of runtime shader optimization",
// "-v", &verbose, "Verbose output",
NULL);
if (ap.parse(argc, argv) < 0 || shadernames.empty()) {
std::cerr << ap.error_message() << std::endl;
ap.usage ();
exit (EXIT_FAILURE);
}
if (help) {
std::cout <<
"testshade -- Test Open Shading Language\n"
"(c) Copyright 2009-2010 Sony Pictures Imageworks Inc. All Rights Reserved.\n";
ap.usage ();
exit (EXIT_SUCCESS);
}
}
int
main(int argc, const char* argv[])
{
Filesystem::convert_native_arguments(argc, argv);
ArgParse ap;
// clang-format off
ap.options ("igrep -- search images for matching metadata\n"
OIIO_INTRO_STRING "\n"
"Usage: igrep [options] pattern filename...",
"%*", parse_files, "",
"-i", &ignore_case, "Ignore upper/lower case distinctions",
"-v", &invert_match, "Invert match (select non-matching files)",
"-E", &extended_regex, "Pattern is an extended regular expression",
"-f", &file_match, "Match against file name as well as metadata",
"-l", &list_files, "List the matching files (no detail)",
"-r", &recursive, "Recurse into directories",
"-d", &print_dirs, "Print directories (when recursive)",
"-a", &all_subimages, "Search all subimages of each file",
"--help", &help, "Print help message",
NULL);
// clang-format off
if (ap.parse(argc, argv) < 0 || pattern.empty() || filenames.empty()) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
return EXIT_FAILURE;
}
if (help) {
ap.usage();
exit(EXIT_FAILURE);
}
#if USE_BOOST_REGEX
boost::regex_constants::syntax_option_type flag
= boost::regex_constants::grep;
if (extended_regex)
flag = boost::regex::extended;
if (ignore_case)
flag |= boost::regex_constants::icase;
#else
auto flag = std::regex_constants::grep;
if (extended_regex)
flag = std::regex_constants::extended;
if (ignore_case)
flag |= std::regex_constants::icase;
#endif
regex re(pattern, flag);
for (auto&& s : filenames)
grep_file(s, re);
return 0;
}
static void
getargs (int argc, const char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("Usage: testtex [options] inputfile",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"-o %s", &output_filename, "Output test image",
"-res %d %d", &output_xres, &output_yres,
"Resolution of output test image",
"-iters %d", &iters,
"Iterations for time trials",
"--blur %f", &blur, "Add blur to texture lookup",
"--width %f", &width, "Multiply filter width of texture lookup",
"--missing %f %f %f", &missing[0], &missing[1], &missing[2],
"Specify missing texture color",
"--autotile %d", &autotile, "Set auto-tile size for the image cache",
"--automip", &automip, "Set auto-MIPmap for the image cache",
"--blocksize %d", &blocksize, "Set blocksize (n x n) for batches",
"--handle", &use_handle, "Use texture handle rather than name lookup",
"--searchpath %s", &searchpath, "Search path for files",
"--nowarp", &nowarp, "Do not warp the image->texture mapping",
"--cachesize %f", &cachesize, "Set cache size, in MB",
"--scale %f", &scalefactor, "Scale intensities",
"--maxfiles %d", &maxfiles, "Set maximum open files",
"--nountiled", &nountiled, "Reject untiled images",
"--nounmipped", &nounmipped, "Reject unmipped images",
"--ctr", &test_construction, "Test TextureOpt construction time",
"--offset %f %f %f", &offset[0], &offset[1], &offset[2], "Offset texture coordinates",
"--scalest %f", &scalest, "Scale st coordinates",
NULL);
if (ap.parse (argc, argv) < 0) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
exit (EXIT_FAILURE);
}
if (help) {
ap.usage ();
exit (EXIT_FAILURE);
}
if (filenames.size() < 1) {
std::cerr << "testtex: Must have at least one input file\n";
ap.usage();
exit (EXIT_FAILURE);
}
}
static void
getargs(int argc, char* argv[])
{
// clang-format off
bool help = false;
ArgParse ap;
ap.options ("idiff -- compare two images\n"
OIIO_INTRO_STRING "\n"
"Usage: idiff [options] image1 image2",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"-q", &quiet, "Quiet (minimal messages)",
"-a", &compareall, "Compare all subimages/miplevels",
"<SEPARATOR>", "Thresholding and comparison options",
"-fail %g", &failthresh, "Failure threshold difference (0.000001)",
"-failpercent %g", &failpercent, "Allow this percentage of failures (0)",
"-hardfail %g", &hardfail, "Fail if any one pixel exceeds this error (infinity)",
"-warn %g", &warnthresh, "Warning threshold difference (0.00001)",
"-warnpercent %g", &warnpercent, "Allow this percentage of warnings (0)",
"-hardwarn %g", &hardwarn, "Warn if any one pixel exceeds this error (infinity)",
"-p", &perceptual, "Perform perceptual (rather than numeric) comparison",
"<SEPARATOR>", "Difference image options",
"-o %s", &diffimage, "Output difference image",
"-od", &outdiffonly, "Output image only if nonzero difference",
"-abs", &diffabs, "Output image of absolute value, not signed difference",
"-scale %g", &diffscale, "Scale the output image by this factor",
// "-meta", &comparemeta, "Compare 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.size() != 2) {
std::cerr << "idiff: Must have two input filenames.\n";
ap.usage();
exit (EXIT_FAILURE);
}
// clang-format on
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("timer_test\n"
OIIO_INTRO_STRING "\n"
"Usage: timer_test [options]",
"%*", parse_files, "",
"--help", &help, "Print help message",
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);
}
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("iv -- image viewer\n"
OIIO_INTRO_STRING "\n"
"Usage: iv [options] [filename...]",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"-F", &foreground_mode, "Foreground mode",
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);
}
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
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",
"-t %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.",
"-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)",
// "--ingamma %f", &ingamma, "Specify gamma of input files (default: 1)",
// "--outgamma %f", &outgamma, "Specify gamma of output files (default: 1)",
// "--opaquewidth %f", &opaquewidth, "Set z fudge factor for volume shadows",
"--fov %f", &fov, "Field of view for envcube/shadcube/twofish",
"--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", &noresize, "Do not resize textures to power of 2 (deprecated)",
"--filter %s", &filtername, filter_help_string().c_str(),
"--nomipmap", &nomipmap, "Do not make multiple MIP-map levels",
"--checknan", &checknan, "Check for NaN and Inf values (abort if found)",
"--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 camera matrix",
"--hash", &embed_hash, "Embed SHA-1 hash of pixels in the header",
"--prman-metadata", &prman_metadata, "Add prman specific metadata",
"--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",
"--stats", &stats, "Print runtime statistics",
//FIXME "-c %s", &channellist, "Restrict/shuffle channels",
//FIXME "-debugdso"
//FIXME "-note %s", ¬e, "Append a note to the image comments",
"<SEPARATOR>", "Basic modes (default is plain texture):",
"--shadow", &shadowmode, "Create shadow map",
// "--shadcube", &shadowcubemode, "Create shadow cube (file order: px,nx,py,ny,pz,nz) (UNIMPLEMENTED)",
// "--volshad", &volshadowmode, "Create volume shadow map (UNIMP)",
"--envlatl", &envlatlmode, "Create lat/long environment map",
"--envcube", &envcubemode, "Create cubic env map (file order: px, nx, py, ny, pz, nz) (UNIMP)",
// "--lightprobe", &lightprobemode, "Convert a lightprobe to cubic env map (UNIMP)",
// "--latl2envcube", &latl2envcubemode, "Convert a lat-long env map to a cubic env map (UNIMP)",
// "--vertcross", &vertcrossmode, "Convert a vertical cross layout to a cubic env map (UNIMP)",
"<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, and constant-color optimizations.",
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);
}
full_command_line = ap.command_line ();
int optionsum = ((int)shadowmode + (int)shadowcubemode + (int)volshadowmode +
(int)envlatlmode + (int)envcubemode +
(int)lightprobemode + (int)vertcrossmode +
(int)latl2envcubemode);
if (optionsum > 1) {
std::cerr << "maketx ERROR: At most one of the following options may be set:\n"
<< "\t--shadow --shadcube --volshad --envlatl --envcube\n"
<< "\t--lightprobe --vertcross --latl2envcube\n";
ap.usage ();
exit (EXIT_FAILURE);
}
if (optionsum == 0)
mipmapmode = true;
if (doresize)
noresize = false;
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";
ap.usage ();
exit (EXIT_FAILURE);
}
if (filenames.size() < 1) {
std::cerr << "maketx ERROR: Must have at least one input filename specified.\n";
ap.usage();
exit (EXIT_FAILURE);
}
filter = setup_filter (filtername);
if (! filter) {
std::cerr << "maketx ERROR: could not make filter '" << filtername << "\n";
exit (EXIT_FAILURE);
}
if (embed_hash && verbose) {
std::cerr << "maketx WARNING: The --embed_hash option is deprecated, and no longer necessary.\n";
std::cerr << " (Hashes are always computed.)\n";
}
// std::cout << "Converting " << filenames[0] << " to " << outputfilename << "\n";
}
int main (int argc, const char* argv[])
{
bool generate = false;
bool extract = false;
int cubesize = 32;
int maxwidth = 2048;
std::string inputfile;
std::string outputfile;
std::string config;
std::string incolorspace;
std::string outcolorspace;
// TODO: Add optional allocation transform instead of colorconvert
ArgParse ap;
ap.options("ociolutimage -- Convert a 3dlut to or from an image\n\n"
"usage: ociolutimage [options] <OUTPUTFILE.LUT>\n\n"
"example: ociolutimage --generate --output lut.exr\n"
"example: ociolutimage --extract --input lut.exr --output output.spi3d\n",
"<SEPARATOR>", "",
"--generate", &generate, "Generate a lattice image",
"--extract", &extract, "Extract a 3dlut from an input image",
"<SEPARATOR>", "",
"--cubesize %d", &cubesize, "Size of the cube (default: 32)",
"--maxwidth %d", &maxwidth, "Specify maximum width of the image (default: 2048)",
"--input %s", &inputfile, "Specify the input filename",
"--output %s", &outputfile, "Specify the output filename",
"<SEPARATOR>", "",
"--config %s", &config, ".ocio configuration file (default: $OCIO)",
"--colorconvert %s %s", &incolorspace, &outcolorspace, "Apply a color space conversion to the image.",
NULL);
if (ap.parse(argc, argv) < 0)
{
std::cout << ap.geterror() << std::endl;
ap.usage();
std::cout << "\n";
return 1;
}
if (argc == 1 )
{
ap.usage();
std::cout << "\n";
return 1;
}
if(generate)
{
try
{
Generate(cubesize, maxwidth,
outputfile,
config, incolorspace, outcolorspace);
}
catch(std::exception & e)
{
std::cerr << "Error generating image: " << e.what() << std::endl;
exit(1);
}
catch(...)
{
std::cerr << "Error generating image. An unknown error occurred.\n";
exit(1);
}
}
else if(extract)
{
try
{
Extract(cubesize, maxwidth,
inputfile, outputfile);
}
catch(std::exception & e)
{
std::cerr << "Error extracting lut: " << e.what() << std::endl;
exit(1);
}
catch(...)
{
std::cerr << "Error extracting lut. An unknown error occurred.\n";
exit(1);
}
}
else
{
std::cerr << "Must specify either --generate or --extract.\n";
exit(1);
}
return 0;
}
static void options_parse(int argc, const char **argv)
{
options.width = 0;
options.height = 0;
options.filepath = "";
options.session = NULL;
options.quiet = false;
/* device names */
string device_names = "";
string devicename = "cpu";
bool list = false;
vector<DeviceType>& types = Device::available_types();
foreach(DeviceType type, types) {
if(device_names != "")
device_names += ", ";
device_names += Device::string_from_type(type);
}
/* shading system */
string ssname = "svm";
/* parse options */
ArgParse ap;
bool help = false;
ap.options ("Usage: cycles [options] file.xml",
"%*", files_parse, "",
"--device %s", &devicename, ("Devices to use: " + device_names).c_str(),
#ifdef WITH_OSL
"--shadingsys %s", &ssname, "Shading system to use: svm, osl",
#endif
"--background", &options.session_params.background, "Render in background, without user interface",
"--quiet", &options.quiet, "In background mode, don't print progress messages",
"--samples %d", &options.session_params.samples, "Number of samples to render",
"--output %s", &options.session_params.output_path, "File path to write output image",
"--threads %d", &options.session_params.threads, "CPU Rendering Threads",
"--width %d", &options.width, "Window width in pixel",
"--height %d", &options.height, "Window height in pixel",
"--list-devices", &list, "List information about all available devices",
"--help", &help, "Print help message",
NULL);
if(ap.parse(argc, argv) < 0) {
fprintf(stderr, "%s\n", ap.geterror().c_str());
ap.usage();
exit(EXIT_FAILURE);
}
else if(list) {
vector<DeviceInfo>& devices = Device::available_devices();
printf("Devices:\n");
foreach(DeviceInfo& info, devices) {
printf(" %s%s\n",
info.description.c_str(),
(info.display_device)? " (display)": "");
}
exit(EXIT_SUCCESS);
}
static void options_parse(int argc, const char **argv)
{
options.width = 0;
options.height = 0;
options.filepath = "";
options.session = NULL;
options.quiet = false;
/* device names */
string device_names = "";
string devicename = "cpu";
bool list = false;
vector<DeviceType>& types = Device::available_types();
/* TODO(sergey): Here's a feedback loop happens: on the one hand we want
* the device list to be printed in help message, on the other hand logging
* is not initialized yet so we wouldn't have debug log happening in the
* device initialization.
*/
foreach(DeviceType type, types) {
if(device_names != "")
device_names += ", ";
device_names += Device::string_from_type(type);
}
/* shading system */
string ssname = "svm";
/* parse options */
ArgParse ap;
bool help = false, debug = false, version = false;
int verbosity = 1;
ap.options ("Usage: cycles [options] file.xml",
"%*", files_parse, "",
"--device %s", &devicename, ("Devices to use: " + device_names).c_str(),
#ifdef WITH_OSL
"--shadingsys %s", &ssname, "Shading system to use: svm, osl",
#endif
"--background", &options.session_params.background, "Render in background, without user interface",
"--quiet", &options.quiet, "In background mode, don't print progress messages",
"--samples %d", &options.session_params.samples, "Number of samples to render",
"--output %s", &options.session_params.output_path, "File path to write output image",
"--threads %d", &options.session_params.threads, "CPU Rendering Threads",
"--width %d", &options.width, "Window width in pixel",
"--height %d", &options.height, "Window height in pixel",
"--list-devices", &list, "List information about all available devices",
#ifdef WITH_CYCLES_LOGGING
"--debug", &debug, "Enable debug logging",
"--verbose %d", &verbosity, "Set verbosity of the logger",
#endif
"--help", &help, "Print help message",
"--version", &version, "Print version number",
NULL);
if(ap.parse(argc, argv) < 0) {
fprintf(stderr, "%s\n", ap.geterror().c_str());
ap.usage();
exit(EXIT_FAILURE);
}
if(debug) {
util_logging_start();
util_logging_verbosity_set(verbosity);
}
if(list) {
vector<DeviceInfo>& devices = Device::available_devices();
printf("Devices:\n");
foreach(DeviceInfo& info, devices) {
printf(" %-10s%s%s\n",
Device::string_from_type(info.type).c_str(),
info.description.c_str(),
(info.display_device)? " (display)": "");
}
exit(EXIT_SUCCESS);
}
int main (int argc, const char* argv[])
{
bool help = false;
int cubesize = -1;
int shapersize = -1; // cubsize^2
std::string format;
std::string inputconfig;
std::string inputspace;
std::string shaperspace;
std::string looks;
std::string outputspace;
bool usestdout = false;
bool verbose = false;
int whitepointtemp = 6505;
std::string displayicc;
std::string description;
std::string copyright = "No copyright. Use freely.";
// What are the allowed baker output formats?
std::ostringstream formats;
formats << "the LUT format to bake: ";
for(int i=0; i<OCIO::Baker::getNumFormats(); ++i)
{
if(i!=0) formats << ", ";
formats << OCIO::Baker::getFormatNameByIndex(i);
formats << " (." << OCIO::Baker::getFormatExtensionByIndex(i) << ")";
}
formats << ", icc (.icc)";
std::string formatstr = formats.str();
std::string dummystr;
float dummyf1, dummyf2, dummyf3;
ArgParse ap;
ap.options("ociobakelut -- create a new LUT or ICC profile from an OCIO config or LUT file(s)\n\n"
"usage: ociobakelut [options] <OUTPUTFILE.LUT>\n\n"
"example: ociobakelut --inputspace lg10 --outputspace srgb8 --format flame lg_to_srgb.3dl\n"
"example: ociobakelut --lut filmlut.3dl --lut calibration.3dl --format flame display.3dl\n"
"example: ociobakelut --cccid 0 --lut cdlgrade.ccc --lut calibration.3dl --format flame graded_display.3dl\n"
"example: ociobakelut --lut look.3dl --offset 0.01 -0.02 0.03 --lut display.3dl --format flame display_with_look.3dl\n"
"example: ociobakelut --inputspace lg10 --outputspace srgb8 --format icc ~/Library/ColorSync/Profiles/test.icc\n"
"example: ociobakelut --lut filmlut.3dl --lut calibration.3dl --format icc ~/Library/ColorSync/Profiles/test.icc\n\n",
"%*", parse_end_args, "",
"<SEPARATOR>", "Using Existing OCIO Configurations",
"--inputspace %s", &inputspace, "Input OCIO ColorSpace (or Role)",
"--outputspace %s", &outputspace, "Output OCIO ColorSpace (or Role)",
"--shaperspace %s", &shaperspace, "the OCIO ColorSpace or Role, for the shaper",
"--looks %s", &looks, "the OCIO looks to apply",
"--iconfig %s", &inputconfig, "Input .ocio configuration file (default: $OCIO)\n",
"<SEPARATOR>", "Config-Free LUT Baking",
"<SEPARATOR>", " (all options can be specified multiple times, each is applied in order)",
"--cccid %s", &dummystr, "Specify a CCCId for any following LUTs",
"--lut %s", &dummystr, "Specify a LUT (forward direction)",
"--invlut %s", &dummystr, "Specify a LUT (inverse direction)",
"--slope %f %f %f", &dummyf1, &dummyf2, &dummyf3, "slope",
"--offset %f %f %f", &dummyf1, &dummyf2, &dummyf3, "offset (float)",
"--offset10 %f %f %f", &dummyf1, &dummyf2, &dummyf3, "offset (10-bit)",
"--power %f %f %f", &dummyf1, &dummyf2, &dummyf3, "power",
"--sat %f", &dummyf1, "saturation (ASC-CDL luma coefficients)\n",
"<SEPARATOR>", "Baking Options",
"--format %s", &format, formatstr.c_str(),
"--shapersize %d", &shapersize, "size of the shaper (default: format specific)",
"--cubesize %d", &cubesize, "size of the cube (default: format specific)",
"--stdout", &usestdout, "Write to stdout (rather than file)",
"--v", &verbose, "Verbose",
"--help", &help, "Print help message\n",
"<SEPARATOR>", "ICC Options",
//"--cubesize %d", &cubesize, "size of the ICC CLUT cube (default: 32)",
"--whitepoint %d", &whitepointtemp, "whitepoint for the profile (default: 6505)",
"--displayicc %s", &displayicc , "an ICC profile which matches the OCIO profiles target display",
"--description %s", &description , "a meaningful description, this will show up in UI like photoshop (defaults to \"filename.icc\")",
"--copyright %s", ©right , "a copyright field (default: \"No copyright. Use freely.\"\n",
// TODO: add --metadata option
NULL);
if (ap.parse(argc, argv) < 0)
{
std::cout << ap.geterror() << std::endl;
ap.usage();
std::cout << "\n";
return 1;
}
if (help || (argc == 1 ))
{
ap.usage();
std::cout << "\n";
return 1;
}
// If we're printing to stdout, disable verbose printouts
if(usestdout)
{
verbose = false;
}
// Create the OCIO processor for the specified transform.
OCIO::ConstConfigRcPtr config;
OCIO::GroupTransformRcPtr groupTransform;
try
{
groupTransform = parse_luts(argc, argv);
}
catch(const OCIO::Exception & e)
{
std::cerr << "\nERROR: " << e.what() << std::endl;
std::cerr << "See --help for more info." << std::endl;
return 1;
}
catch(...)
{
std::cerr << "\nERROR: An unknown error occurred in parse_luts" << std::endl;
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(!groupTransform)
{
std::cerr << "\nERROR: parse_luts returned null transform" << std::endl;
std::cerr << "See --help for more info." << std::endl;
return 1;
}
// If --luts have been specified, synthesize a new (temporary) configuration
// with the transformation embedded in a colorspace.
if(!groupTransform->empty())
{
if(!inputspace.empty())
{
std::cerr << "\nERROR: --inputspace is not allowed when using --lut\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(!outputspace.empty())
{
std::cerr << "\nERROR: --outputspace is not allowed when using --lut\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(!looks.empty())
{
std::cerr << "\nERROR: --looks is not allowed when using --lut\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(!shaperspace.empty())
{
std::cerr << "\nERROR: --shaperspace is not allowed when using --lut\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
OCIO::ConfigRcPtr editableConfig = OCIO::Config::Create();
OCIO::ColorSpaceRcPtr inputColorSpace = OCIO::ColorSpace::Create();
inputspace = "RawInput";
inputColorSpace->setName(inputspace.c_str());
editableConfig->addColorSpace(inputColorSpace);
OCIO::ColorSpaceRcPtr outputColorSpace = OCIO::ColorSpace::Create();
outputspace = "ProcessedOutput";
outputColorSpace->setName(outputspace.c_str());
outputColorSpace->setTransform(groupTransform,
OCIO::COLORSPACE_DIR_FROM_REFERENCE);
if(verbose)
{
std::cout << "[OpenColorIO DEBUG]: Specified Transform:";
std::cout << *groupTransform;
std::cout << "\n";
}
editableConfig->addColorSpace(outputColorSpace);
config = editableConfig;
}
else
{
if(inputspace.empty())
{
std::cerr << "\nERROR: You must specify the --inputspace.\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(outputspace.empty())
{
std::cerr << "\nERROR: You must specify the --outputspace.\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(format.empty())
{
std::cerr << "\nERROR: You must specify the LUT format using --format.\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(!inputconfig.empty())
{
if(!usestdout && verbose)
std::cout << "[OpenColorIO INFO]: Loading " << inputconfig << std::endl;
config = OCIO::Config::CreateFromFile(inputconfig.c_str());
}
else if(getenv("OCIO"))
{
if(!usestdout && verbose)
std::cout << "[OpenColorIO INFO]: Loading $OCIO " << getenv("OCIO") << std::endl;
config = OCIO::Config::CreateFromEnv();
}
else
{
std::cerr << "ERROR: You must specify an input OCIO configuration ";
std::cerr << "(either with --iconfig or $OCIO).\n\n";
ap.usage ();
return 1;
}
}
if(outputfile.empty() && !usestdout)
{
std::cerr << "\nERROR: You must specify the outputfile or --stdout.\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
try
{
if(format == "icc")
{
if(description.empty())
{
description = outputfile;
if(verbose)
std::cout << "[OpenColorIO INFO]: \"--description\" set to default value of filename.icc: " << outputfile << "" << std::endl;
}
if(usestdout)
{
std::cerr << "\nERROR: --stdout not supported when writing ICC profiles.\n\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(outputfile.empty())
{
std::cerr << "ERROR: you need to specify a output ICC path\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
if(cubesize<2) cubesize = 32; // default
OCIO::ConstProcessorRcPtr processor;
if (!looks.empty())
{
OCIO::LookTransformRcPtr transform =
OCIO::LookTransform::Create();
transform->setLooks(looks.c_str());
transform->setSrc(inputspace.c_str());
transform->setDst(outputspace.c_str());
processor = config->getProcessor(transform,
OCIO::TRANSFORM_DIR_FORWARD);
}
else
{
processor = config->getProcessor(inputspace.c_str(),
outputspace.c_str());
}
SaveICCProfileToFile(outputfile,
processor,
cubesize,
whitepointtemp,
displayicc,
description,
copyright,
verbose);
}
else
{
OCIO::BakerRcPtr baker = OCIO::Baker::Create();
// setup the baker for our LUT type
baker->setConfig(config);
baker->setFormat(format.c_str());
baker->setInputSpace(inputspace.c_str());
baker->setShaperSpace(shaperspace.c_str());
baker->setLooks(looks.c_str());
baker->setTargetSpace(outputspace.c_str());
if(shapersize!=-1) baker->setShaperSize(shapersize);
if(cubesize!=-1) baker->setCubeSize(cubesize);
// output LUT
std::ostringstream output;
if(!usestdout && verbose)
std::cout << "[OpenColorIO INFO]: Baking '" << format << "' LUT" << std::endl;
if(usestdout)
{
baker->bake(std::cout);
}
else
{
std::ofstream f(outputfile.c_str());
baker->bake(f);
if(verbose)
std::cout << "[OpenColorIO INFO]: Wrote '" << outputfile << "'" << std::endl;
}
}
}
catch(OCIO::Exception & exception)
{
std::cerr << "OCIO Error: " << exception.what() << std::endl;
std::cerr << "See --help for more info." << std::endl;
return 1;
}
catch (std::exception& exception)
{
std::cerr << "Error: " << exception.what() << "\n";
std::cerr << "See --help for more info." << std::endl;
return 1;
}
catch(...)
{
std::cerr << "Unknown OCIO error encountered." << std::endl;
std::cerr << "See --help for more info." << std::endl;
return 1;
}
return 0;
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
ArgParse ap;
ap.options ("iconvert -- copy images with format conversions and other alterations\n"
OIIO_INTRO_STRING "\n"
"Usage: iconvert [options] inputfile outputfile\n"
" or: iconvert --inplace [options] file...\n",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose status messages",
"--threads %d", &nthreads, "Number of threads (default 0 = #cores)",
"-d %s", &dataformatname, "Set the output data format to one of:"
"uint8, sint8, uint10, uint12, uint16, sint16, half, float, double",
"-g %f", &gammaval, "Set gamma correction (default = 1)",
"--tile %d %d", &tile[0], &tile[1], "Output as a tiled image",
"--scanline", &scanline, "Output as a scanline image",
"--compression %s", &compression, "Set the compression method (default = same as input)",
"--quality %d", &quality, "Set the compression quality, 1-100",
"--no-copy-image", &no_copy_image, "Do not use ImageOutput copy_image functionality (dbg)",
"--adjust-time", &adjust_time, "Adjust file times to match DateTime metadata",
"--caption %s", &caption, "Set caption (ImageDescription)",
"--keyword %L", &keywords, "Add a keyword",
"--clear-keywords", &clear_keywords, "Clear keywords",
"--attrib %L %L", &attribnames, &attribvals, "Set a string attribute (name, value)",
"--orientation %d", &orientation, "Set the orientation",
"--rotcw", &rotcw, "Rotate 90 deg clockwise",
"--rotccw", &rotccw, "Rotate 90 deg counter-clockwise",
"--rot180", &rot180, "Rotate 180 deg",
"--inplace", &inplace, "Do operations in place on images",
"--sRGB", &sRGB, "This file is in sRGB color space",
"--separate", &separate, "Force planarconfig separate",
"--contig", &contig, "Force planarconfig contig",
"--no-clobber", &noclobber, "Do no overwrite existing files",
//FIXME "-z", &zfile, "Treat input as a depth file",
//FIXME "-c %s", &channellist, "Restrict/shuffle channels",
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.size() != 2 && ! inplace) {
std::cerr << "iconvert: Must have both an input and output filename specified.\n";
ap.usage();
exit (EXIT_FAILURE);
}
if (filenames.size() == 0 && inplace) {
std::cerr << "iconvert: Must have at least one filename\n";
ap.usage();
exit (EXIT_FAILURE);
}
if (((int)rotcw + (int)rotccw + (int)rot180 + (orientation>0)) > 1) {
std::cerr << "iconvert: more than one of --rotcw, --rotccw, --rot180, --orientation\n";
ap.usage();
exit (EXIT_FAILURE);
}
}
int main(int argc, const char **argv)
{
bool help = false;
int errorcount = 0;
std::string inputconfig;
std::string outputconfig;
ArgParse ap;
ap.options("ociocheck -- validate an OpenColorIO configuration\n\n"
"usage: ociocheck [options]\n",
"--help", &help, "Print help message",
"--iconfig %s", &inputconfig, "Input .ocio configuration file (default: $OCIO)",
"--oconfig %s", &outputconfig, "Output .ocio file",
NULL);
if (ap.parse(argc, argv) < 0)
{
std::cout << ap.geterror() << std::endl;
ap.usage();
std::cout << DESC_STRING;
return 1;
}
if (help)
{
ap.usage();
std::cout << DESC_STRING;
return 1;
}
try
{
OCIO::ConstConfigRcPtr config;
std::cout << std::endl;
std::cout << "OpenColorIO Library Version: " << OCIO::GetVersion() << std::endl;
std::cout << "OpenColorIO Library VersionHex: " << OCIO::GetVersionHex() << std::endl;
if(!inputconfig.empty())
{
std::cout << "Loading " << inputconfig << std::endl;
config = OCIO::Config::CreateFromFile(inputconfig.c_str());
}
else if(getenv("OCIO"))
{
std::cout << "Loading $OCIO " << getenv("OCIO") << std::endl;
config = OCIO::Config::CreateFromEnv();
}
else
{
std::cout << "ERROR: You must specify an input OCIO configuration ";
std::cout << "(either with --iconfig or $OCIO).\n";
ap.usage ();
std::cout << DESC_STRING;
return 1;
}
std::cout << std::endl;
std::cout << "** General **" << std::endl;
std::cout << "Search Path: " << config->getSearchPath() << std::endl;
std::cout << "Working Dir: " << config->getWorkingDir() << std::endl;
std::cout << std::endl;
std::cout << "Default Display: " << config->getDefaultDisplay() << std::endl;
std::cout << "Default View: " << config->getDefaultView(config->getDefaultDisplay()) << std::endl;
{
std::cout << std::endl;
std::cout << "** Roles **" << std::endl;
std::set<std::string> usedroles;
const char * allroles[] = { OCIO::ROLE_DEFAULT, OCIO::ROLE_SCENE_LINEAR,
OCIO::ROLE_DATA, OCIO::ROLE_REFERENCE,
OCIO::ROLE_COMPOSITING_LOG, OCIO::ROLE_COLOR_TIMING,
OCIO::ROLE_COLOR_PICKING,
OCIO::ROLE_TEXTURE_PAINT, OCIO::ROLE_MATTE_PAINT,
NULL };
int MAXROLES=256;
for(int i=0;i<MAXROLES; ++i)
{
const char * role = allroles[i];
if(!role) break;
usedroles.insert(role);
OCIO::ConstColorSpaceRcPtr cs = config->getColorSpace(role);
if(cs)
{
std::cout << cs->getName() << " (" << role << ")" << std::endl;
}
else
{
std::cout << "ERROR: NOT DEFINED" << " (" << role << ")" << std::endl;
errorcount += 1;
}
}
for(int i=0; i<config->getNumRoles(); ++i)
{
const char * role = config->getRoleName(i);
if(usedroles.find(role) != usedroles.end()) continue;
OCIO::ConstColorSpaceRcPtr cs = config->getColorSpace(role);
if(cs)
{
std::cout << cs->getName() << " (" << role << ": user)" << std::endl;
}
else
{
std::cout << "ERROR: NOT DEFINED" << " (" << role << ")" << std::endl;
errorcount += 1;
}
}
}
std::cout << std::endl;
std::cout << "** ColorSpaces **" << std::endl;
OCIO::ConstColorSpaceRcPtr lin = config->getColorSpace(OCIO::ROLE_SCENE_LINEAR);
if(!lin)
{
std::cout << "Error: scene_linear role must be defined." << std::endl;
errorcount += 1;
}
else
{
for(int i=0; i<config->getNumColorSpaces(); ++i)
{
OCIO::ConstColorSpaceRcPtr cs = config->getColorSpace(config->getColorSpaceNameByIndex(i));
bool convertsToLinear = true;
std::string convertsToLinearErrorText;
bool convertsFromLinear = true;
std::string convertsFromLinearErrorText;
try
{
OCIO::ConstProcessorRcPtr p = config->getProcessor(cs, lin);
}
catch(OCIO::Exception & exception)
{
convertsToLinear = false;
convertsToLinearErrorText = exception.what();
}
try
{
OCIO::ConstProcessorRcPtr p = config->getProcessor(lin, cs);
}
catch(OCIO::Exception & exception)
{
convertsFromLinear = false;
convertsFromLinearErrorText = exception.what();
}
if(convertsToLinear && convertsFromLinear)
{
std::cout << cs->getName() << std::endl;
}
else if(!convertsToLinear && !convertsFromLinear)
{
std::cout << cs->getName();
std::cout << " -- error" << std::endl;
std::cout << "\t" << convertsToLinearErrorText << std::endl;
std::cout << "\t" << convertsFromLinearErrorText << std::endl;
errorcount += 1;
}
else if(convertsToLinear)
{
std::cout << cs->getName();
std::cout << " -- input only" << std::endl;
}
else if(convertsFromLinear)
{
std::cout << cs->getName();
std::cout << " -- output only" << std::endl;
}
}
}
std::cout << std::endl;
std::cout << "** Looks **" << std::endl;
if(config->getNumLooks()>0)
{
for(int i=0; i<config->getNumLooks(); ++i)
{
std::cout << config->getLookNameByIndex(i) << std::endl;
}
}
else
{
std::cout << "no looks defined" << std::endl;
}
std::cout << std::endl;
std::cout << "** Sanity Check **" << std::endl;
try
{
config->sanityCheck();
std::cout << "passed" << std::endl;
}
catch(OCIO::Exception & exception)
{
std::cout << "ERROR" << std::endl;
errorcount += 1;
std::cout << exception.what() << std::endl;
}
if(!outputconfig.empty())
{
std::ofstream output;
output.open(outputconfig.c_str());
if(!output.is_open())
{
std::cout << "Error opening " << outputconfig << " for writing." << std::endl;
}
else
{
config->serialize(output);
output.close();
std::cout << "Wrote " << outputconfig << std::endl;
}
}
}
catch(OCIO::Exception & exception)
{
std::cout << "ERROR: " << exception.what() << std::endl;
return 1;
} catch (std::exception& exception) {
std::cout << "ERROR: " << exception.what() << "\n";
return 1;
}
catch(...)
{
std::cout << "Unknown error encountered." << std::endl;
return 1;
}
std::cout << std::endl;
if(errorcount == 0)
{
std::cout << "Tests complete." << std::endl << std::endl;
return 0;
}
else
{
std::cout << errorcount << " tests failed." << std::endl << std::endl;
return 1;
}
}
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);
}
}
int
main (int argc, const char *argv[])
{
Filesystem::convert_native_arguments (argc, (const char **)argv);
ArgParse ap;
ap.options ("iinfo -- print information about images\n"
OIIO_INTRO_STRING "\n"
"Usage: iinfo [options] filename...",
"%*", parse_files, "",
"--help", &help, "Print help message",
"-v", &verbose, "Verbose output",
"-m %s", &metamatch, "Metadata names to print (default: all)",
"-f", &filenameprefix, "Prefix each line with the filename",
"-s", &sum, "Sum the image sizes",
"-a", &subimages, "Print info about all subimages",
"--hash", &compute_sha1, "Print SHA-1 hash of pixel values",
"--stats", &compute_stats, "Print image pixel statistics (data window)",
NULL);
if (ap.parse(argc, argv) < 0 || filenames.empty()) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
return EXIT_FAILURE;
}
if (help) {
ap.usage ();
exit (EXIT_FAILURE);
}
if (! metamatch.empty())
field_re.assign (metamatch,
boost::regex::extended | boost::regex_constants::icase);
// Find the longest filename
size_t longestname = 0;
BOOST_FOREACH (const std::string &s, filenames)
longestname = std::max (longestname, s.length());
longestname = std::min (longestname, (size_t)40);
long long totalsize = 0;
BOOST_FOREACH (const std::string &s, filenames) {
ImageInput *in = ImageInput::open (s.c_str());
if (! in) {
std::string err = geterror();
if (err.empty())
err = Strutil::format ("Could not open \"%s\"", s.c_str());
std::cerr << "iinfo: " << err << "\n";
continue;
}
ImageSpec spec = in->spec();
print_info (s, longestname, in, spec, verbose, sum, totalsize);
in->close ();
delete in;
}