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;
int nchannels = -1;
bool prman = false;
bool oiio = false;
bool ignore_unassoc = false; // ignore unassociated alpha tags
bool unpremult = false;
std::string incolorspace;
std::string outcolorspace;
std::string channelnames;
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",
"--new", NULL, "",
"--old", NULL, "Old mode",
"--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.",
"--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",
"--hash", NULL, "",
"--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",
"--opaque-detect", &opaque_detect, "Drop alpha channel that is always 1.0",
"--ignore-unassoc", &ignore_unassoc, "Ignore unassociated alpha tags in input (don't autoconvert)",
"--stats", &stats, "Print runtime statistics",
"--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",
// "--envcube", &envcubemode, "Create cubic env map (file order: px, nx, py, ny, pz, nz) (UNIMP)",
"<SEPARATOR>", colortitle_help_string().c_str(),
"--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 || filenames.empty()) {
ap.usage ();
exit (EXIT_FAILURE);
}
int optionsum = ((int)shadowmode + (int)envlatlmode + (int)envcubemode +
(int)lightprobemode);
if (optionsum > 1) {
std::cerr << "maketx ERROR: At most one of the following options may be set:\n"
<< "\t--shadow --envlatl --envcube --lightprobe\n";
ap.usage ();
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";
ap.usage ();
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;
}
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", TypeDesc::TypeMatrix, &Mcam);
if (Mscr != Imath::M44f(0.0f))
configspec.attribute ("worldtoscreen", TypeDesc::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:stats", stats);
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:unpremult", unpremult);
configspec.attribute ("maketx:incolorspace", incolorspace);
configspec.attribute ("maketx:outcolorspace", outcolorspace);
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);
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, ap.command_line());
configspec.attribute ("Software", cmdline);
configspec.attribute ("maketx:full_command_line", cmdline);
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);
}
}
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 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;
}
}
