// ColorConfig utility to take inventory of the color spaces available.
// It sets up knowledge of "linear", "sRGB", "Rec709",
// even if the underlying OCIO configuration lacks them.
void
ColorConfig::Impl::inventory ()
{
#ifdef USE_OCIO
if (config_) {
bool nonraw = false;
for (int i = 0, e = config_->getNumColorSpaces(); i < e; ++i)
nonraw |= ! Strutil::iequals(config_->getColorSpaceNameByIndex(i), "raw");
if (nonraw) {
for (int i = 0, e = config_->getNumColorSpaces(); i < e; ++i)
add (config_->getColorSpaceNameByIndex(i), i);
OCIO::ConstColorSpaceRcPtr lin = config_->getColorSpace ("scene_linear");
if (lin)
linear_alias = lin->getName();
return; // If any non-"raw" spaces were defined, we're done
}
}
// If we had some kind of bogus configuration that seemed to define
// only a "raw" color space and nothing else, that's useless, so
// figure out our own way to move forward.
config_.reset();
#endif
// If there was no configuration, or we didn't compile with OCIO
// support at all, register a few basic names we know about.
add ("linear", 0);
add ("sRGB", 1);
add ("Rec709", 2);
}
const char *
ColorConfig::getColorSpaceNameByRole (string_view role) const
{
#ifdef USE_OCIO
if (getImpl()->config_) {
OCIO::ConstColorSpaceRcPtr c = getImpl()->config_->getColorSpace (role.c_str());
// Catch special case of obvious name synonyms
if (!c && Strutil::iequals(role,"linear"))
c = getImpl()->config_->getColorSpace ("scene_linear");
if (!c && Strutil::iequals(role,"scene_linear"))
c = getImpl()->config_->getColorSpace ("linear");
if (c)
return c->getName();
}
#endif
// No OCIO at build time, or no OCIO configuration at run time
if (Strutil::iequals (role, "linear") || Strutil::iequals (role, "scene_linear"))
return "linear";
return NULL; // Dunno what role
}
// ColorConfig utility to take inventory of the color spaces available.
// It sets up knowledge of "linear", "sRGB", "Rec709",
// even if the underlying OCIO configuration lacks them.
void
ColorConfig::Impl::inventory ()
{
#ifdef USE_OCIO
if (config_) {
for (int i = 0, e = config_->getNumColorSpaces(); i < e; ++i) {
std::string name = config_->getColorSpaceNameByIndex(i);
add (name, i);
}
OCIO::ConstColorSpaceRcPtr lin = config_->getColorSpace ("scene_linear");
if (lin)
linear_alias = lin->getName();
}
if (colorspaces.size())
return; // If any were defined, we're done
#endif
// If there was no configuration, or we didn't compile with OCIO
// support at all, register a few basic names we know about.
add ("linear", 0);
add ("sRGB", 1);
add ("Rec709", 2);
}
std::string
HdxColorCorrectionTask::_CreateOpenColorIOResources()
{
#ifdef PXR_OCIO_PLUGIN_ENABLED
// Use client provided OCIO values, or use default fallback values
OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
const char* display = _displayOCIO.empty() ?
config->getDefaultDisplay() :
_displayOCIO.c_str();
const char* view = _viewOCIO.empty() ?
config->getDefaultView(display) :
_viewOCIO.c_str();
std::string inputColorSpace = _colorspaceOCIO;
if (inputColorSpace.empty()) {
OCIO::ConstColorSpaceRcPtr cs = config->getColorSpace("default");
if (cs) {
inputColorSpace = cs->getName();
} else {
inputColorSpace = OCIO::ROLE_SCENE_LINEAR;
}
}
// Setup the transformation we need to apply
OCIO::DisplayTransformRcPtr transform = OCIO::DisplayTransform::Create();
transform->setDisplay(display);
transform->setView(view);
transform->setInputColorSpaceName(inputColorSpace.c_str());
if (!_looksOCIO.empty()) {
transform->setLooksOverride(_looksOCIO.c_str());
transform->setLooksOverrideEnabled(true);
} else {
transform->setLooksOverrideEnabled(false);
}
OCIO::ConstProcessorRcPtr processor = config->getProcessor(transform);
// Create a GPU Shader Description
OCIO::GpuShaderDesc shaderDesc;
shaderDesc.setLanguage(OCIO::GPU_LANGUAGE_GLSL_1_0);
shaderDesc.setFunctionName("OCIODisplay");
shaderDesc.setLut3DEdgeLen(_lut3dSizeOCIO);
// Compute and the 3D LUT
int num3Dentries = 3 * _lut3dSizeOCIO*_lut3dSizeOCIO*_lut3dSizeOCIO;
std::vector<float> lut3d;
lut3d.resize(num3Dentries);
processor->getGpuLut3D(&lut3d[0], shaderDesc);
// Load the data into an OpenGL 3D Texture
if (_texture3dLUT != 0) {
glDeleteTextures(1, &_texture3dLUT);
}
GLint restoreTexture;
glGetIntegerv(GL_TEXTURE_BINDING_3D, &restoreTexture);
glGenTextures(1, &_texture3dLUT);
glBindTexture(GL_TEXTURE_3D, _texture3dLUT);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB32F,
_lut3dSizeOCIO, _lut3dSizeOCIO, _lut3dSizeOCIO,
0, GL_RGB, GL_FLOAT, &lut3d[0]);
glBindTexture(GL_TEXTURE_3D, restoreTexture);
const char* gpuShaderText = processor->getGpuShaderText(shaderDesc);
GLF_POST_PENDING_GL_ERRORS();
return std::string(gpuShaderText);
#else
return std::string();
#endif
}
void
GenericOCIO::changedParam(const OFX::InstanceChangedArgs &args, const std::string ¶mName)
{
assert(_created);
#ifdef OFX_IO_USING_OCIO
if (paramName == kOCIOParamConfigFile) {
// compute canonical inputSpace and outputSpace before changing the config,
// if different from inputSpace and outputSpace they must be set to the canonical value after changing ocio config
std::string inputSpace;
getInputColorspaceAtTime(args.time, inputSpace);
std::string inputSpaceCanonical = canonicalizeColorSpace(_config, inputSpace);
if (inputSpaceCanonical != inputSpace) {
_inputSpace->setValue(inputSpaceCanonical);
}
std::string outputSpace;
getOutputColorspaceAtTime(args.time, outputSpace);
std::string outputSpaceCanonical = canonicalizeColorSpace(_config, outputSpace);
if (outputSpaceCanonical != outputSpace) {
_outputSpace->setValue(outputSpaceCanonical);
}
loadConfig(); // re-load the new OCIO config
//if inputspace or outputspace are not valid in the new config, reset them to "default"
if (_config) {
std::string inputSpaceName;
getInputColorspaceAtTime(args.time, inputSpaceName);
int inputSpaceIndex = _config->getIndexForColorSpace(inputSpaceName.c_str());
if (inputSpaceIndex < 0) {
_inputSpace->setValue(OCIO_NAMESPACE::ROLE_DEFAULT);
}
}
inputCheck(args.time);
if (_config) {
std::string outputSpaceName;
getOutputColorspaceAtTime(args.time, outputSpaceName);
int outputSpaceIndex = _config->getIndexForColorSpace(outputSpaceName.c_str());
if (outputSpaceIndex < 0) {
_outputSpace->setValue(OCIO_NAMESPACE::ROLE_DEFAULT);
}
}
outputCheck(args.time);
if (!_config && args.reason == OFX::eChangeUserEdit) {
std::string filename;
_ocioConfigFile->getValue(filename);
_parent->sendMessage(OFX::Message::eMessageError, "", std::string("Cannot load OCIO config file \"") + filename + '"');
}
} else if (paramName == kOCIOHelpButton || paramName == kOCIOHelpLooksButton || paramName == kOCIOHelpDisplaysButton) {
std::string msg = "OpenColorIO Help\n"
"The OCIO configuration file can be set using the \"OCIO\" environment variable, which should contain the full path to the .ocio file.\n"
"OpenColorIO version (compiled with / running with): " OCIO_VERSION "/";
msg += OCIO_NAMESPACE::GetVersion();
msg += '\n';
if (_config) {
std::string configdesc = _config->getDescription();
configdesc = whitespacify(trim(configdesc));
if ( configdesc.size() > 0 ) {
msg += "\nThis OCIO configuration is ";
msg += configdesc;
msg += '\n';
}
msg += '\n';
if (paramName == kOCIOHelpLooksButton) {
msg += (_config->getNumLooks() <= 0 ? "No look available in this OCIO configuration.\n" : "Available looks in this OCIO Configuration (applied in the given colorspace):\n");
for (int i = 0; i < _config->getNumLooks(); ++i) {
const char* lkname = _config->getLookNameByIndex(i);
OCIO_NAMESPACE::ConstLookRcPtr lk = _config->getLook(lkname);
msg += "- ";
msg += lkname;
std::string lkspace = lk->getProcessSpace();
msg += " (" + lkspace + ")\n";
}
msg += '\n';
}
if (paramName == kOCIOHelpDisplaysButton) {
if (_config->getNumDisplays() <= 0) {
msg += "No display available in this OCIO configuration.\n";
} else {
msg += "Available displays and views in this OCIO Configuration:\n";
std::string defaultdisplay = _config->getDefaultDisplay();
for (int i = 0; i < _config->getNumDisplays(); ++i) {
const char* display = _config->getDisplay(i);
msg += "- ";
msg += display;
if (display == defaultdisplay) {
msg += " (default)";
}
int numViews = _config->getNumViews(display);
if (numViews <= 0) {
msg += ", no view available.\n";
} else {
msg += ", views: ";
std::string defaultview = _config->getDefaultView(display);
for (int j = 0; j < numViews; ++j) {
const char* view = _config->getView(display, j);
msg += view;
if (view == defaultview) {
msg += " (default)";
}
if (j < numViews-1) {
msg += ", ";
}
}
msg += '\n';
}
}
}
msg += '\n';
}
msg += "Available colorspaces in this OCIO Configuration:\n";
int defaultcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_DEFAULT);
int referencecs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_REFERENCE);
int datacs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_DATA);
int colorpickingcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_COLOR_PICKING);
int scenelinearcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_SCENE_LINEAR);
int compositinglogcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_COMPOSITING_LOG);
int colortimingcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_COLOR_TIMING);
int texturepaintcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_TEXTURE_PAINT);
int mattepaintcs = _config->getIndexForColorSpace(OCIO_NAMESPACE::ROLE_MATTE_PAINT);
for (int i = 0; i < _config->getNumColorSpaces(); ++i) {
const char* csname = _config->getColorSpaceNameByIndex(i);;
OCIO_NAMESPACE::ConstColorSpaceRcPtr cs = _config->getColorSpace(csname);
msg += "- ";
msg += csname;
bool first = true;
//int roles = 0;
if (i == defaultcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_DEFAULT;
first = false;
//++roles;
}
if (i == referencecs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_REFERENCE;
first = false;
//++roles;
}
if (i == datacs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_DATA;
first = false;
//++roles;
}
if (i == colorpickingcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_COLOR_PICKING;
first = false;
//++roles;
}
if (i == scenelinearcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_SCENE_LINEAR;
first = false;
//++roles;
}
if (i == compositinglogcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_COMPOSITING_LOG;
first = false;
//++roles;
}
if (i == colortimingcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_COLOR_TIMING;
first = false;
//++roles;
}
if (i == texturepaintcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_TEXTURE_PAINT;
first = false;
//++roles;
}
if (i == mattepaintcs) {
msg += first ? " (" : ", ";
msg += OCIO_NAMESPACE::ROLE_MATTE_PAINT;
first = false;
//++roles;
}
if (!first /*&& roles > 0*/) {
msg += ')';
}
std::string csdesc = cs ? cs->getDescription() : "(no colorspace)";
csdesc = whitespacify(trim(csdesc));
if ( !csdesc.empty() ) {
msg += ": ";
msg += csdesc;
msg += '\n';
} else {
msg += '\n';
}
}
}
_parent->sendMessage(OFX::Message::eMessageMessage, "", msg);
} else if (!_config) {
// the other parameters assume there is a valid config
return;
} else if (paramName == kOCIOParamInputSpace) {
assert(_inputSpace);
if (args.reason == OFX::eChangeUserEdit) {
// if the inputspace doesn't correspond to a valid one, reset to default.
// first, canonicalize.
std::string inputSpace;
getInputColorspaceAtTime(args.time, inputSpace);
std::string inputSpaceCanonical = canonicalizeColorSpace(_config, inputSpace);
if (inputSpaceCanonical != inputSpace) {
_inputSpace->setValue(inputSpaceCanonical);
inputSpace = inputSpaceCanonical;
}
int inputSpaceIndex = _config->getIndexForColorSpace(inputSpace.c_str());
if (inputSpaceIndex < 0) {
if (args.reason == OFX::eChangeUserEdit) {
_parent->sendMessage(OFX::Message::eMessageWarning, "", std::string("Unknown OCIO colorspace \"")+inputSpace+"\"");
}
OCIO::ConstColorSpaceRcPtr colorspace = _config->getColorSpace(OCIO_NAMESPACE::ROLE_DEFAULT);
if (colorspace) {
inputSpace = colorspace->getName();
_inputSpace->setValue(inputSpace);
}
}
}
inputCheck(args.time);
}
#ifdef OFX_OCIO_CHOICE
else if ( paramName == kOCIOParamInputSpaceChoice && args.reason == OFX::eChangeUserEdit) {
assert(_inputSpace);
int inputSpaceIndex;
_inputSpaceChoice->getValueAtTime(args.time, inputSpaceIndex);
std::string inputSpaceOld;
getInputColorspaceAtTime(args.time, inputSpaceOld);
std::string inputSpace = canonicalizeColorSpace(_config, _config->getColorSpaceNameByIndex(inputSpaceIndex));
// avoid an infinite loop on bad hosts (for examples those which don't set args.reason correctly)
if (inputSpace != inputSpaceOld) {
_inputSpace->setValue(inputSpace);
}
}
#endif
else if (paramName == kOCIOParamOutputSpace) {
assert(_outputSpace);
if (args.reason == OFX::eChangeUserEdit) {
// if the outputspace doesn't correspond to a valid one, reset to default.
// first, canonicalize.
std::string outputSpace;
getOutputColorspaceAtTime(args.time, outputSpace);
std::string outputSpaceCanonical = canonicalizeColorSpace(_config, outputSpace);
if (outputSpaceCanonical != outputSpace) {
_outputSpace->setValue(outputSpaceCanonical);
outputSpace = outputSpaceCanonical;
}
int outputSpaceIndex = _config->getIndexForColorSpace(outputSpace.c_str());
if (outputSpaceIndex < 0) {
if (args.reason == OFX::eChangeUserEdit) {
_parent->sendMessage(OFX::Message::eMessageWarning, "", std::string("Unknown OCIO colorspace \"")+outputSpace+"\"");
}
outputSpace = _config->getColorSpace(OCIO_NAMESPACE::ROLE_DEFAULT)->getName();
_outputSpace->setValue(outputSpace);
outputSpaceIndex = _config->getIndexForColorSpace(outputSpace.c_str());
assert(outputSpaceIndex >= 0);
}
}
outputCheck(args.time);
}
#ifdef OFX_OCIO_CHOICE
else if ( paramName == kOCIOParamOutputSpaceChoice && args.reason == OFX::eChangeUserEdit) {
assert(_outputSpace);
int outputSpaceIndex;
_outputSpaceChoice->getValueAtTime(args.time, outputSpaceIndex);
std::string outputSpaceOld;
getOutputColorspaceAtTime(args.time, outputSpaceOld);
std::string outputSpace = canonicalizeColorSpace(_config, _config->getColorSpaceNameByIndex(outputSpaceIndex));
// avoid an infinite loop on bad hosts (for examples those which don't set args.reason correctly)
if (outputSpace != outputSpaceOld) {
_outputSpace->setValue(outputSpace);
}
}
#endif // OFX_OCIO_CHOICE
#endif
}
OCIOLookTransform::OCIOLookTransform(Node *n) : DD::Image::PixelIop(n)
{
m_hasColorSpaces = false;
m_inputColorSpaceIndex = 0;
m_outputColorSpaceIndex = 0;
m_lookIndex = 0;
m_dirIndex = 0;
m_ignoreErrors = false;
// Query the colorspace names from the current config
// TODO (when to) re-grab the list of available colorspaces? How to save/load?
OCIO::ConstConfigRcPtr config;
std::string linear;
try
{
config = OCIO::GetCurrentConfig();
OCIO::ConstColorSpaceRcPtr linearcs = config->getColorSpace(OCIO::ROLE_SCENE_LINEAR);
if(!linearcs) throw std::runtime_error("ROLE_SCENE_LINEAR not defined.");
linear = linearcs->getName();
}
catch (const OCIO::Exception& e)
{
std::cerr << "OCIOLookTransform: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "OCIOLookTransform: Unknown exception during OCIO setup." << std::endl;
}
if(!config)
{
m_hasColorSpaces = false;
return;
}
// Step 1: Make the std::vectors
for(int i=0; i<config->getNumLooks(); ++i)
{
m_lookNames.push_back(config->getLookNameByIndex(i));
}
for(int i = 0; i < config->getNumColorSpaces(); i++)
{
std::string csname = config->getColorSpaceNameByIndex(i);
#ifdef OCIO_CASCADE
std::string family = config->getColorSpace(csname.c_str())->getFamily();
if(family.empty())
m_colorSpaceNames.push_back(csname.c_str());
else
m_colorSpaceNames.push_back(family + "/" + csname);
#else
m_colorSpaceNames.push_back(csname);
#endif
if(csname == linear)
{
m_inputColorSpaceIndex = i;
m_outputColorSpaceIndex = i;
}
}
// Step 2: Create a cstr array for passing to Nuke
// (This must be done in a second pass, lest the original strings be reallocated)
for(unsigned int i=0; i<m_lookNames.size(); ++i)
{
m_lookCstrNames.push_back(m_lookNames[i].c_str());
}
m_lookCstrNames.push_back(NULL);
for(unsigned int i=0; i<m_colorSpaceNames.size(); ++i)
{
m_inputColorSpaceCstrNames.push_back(m_colorSpaceNames[i].c_str());
m_outputColorSpaceCstrNames.push_back(m_colorSpaceNames[i].c_str());
}
m_inputColorSpaceCstrNames.push_back(NULL);
m_outputColorSpaceCstrNames.push_back(NULL);
m_hasColorSpaces = (!m_colorSpaceNames.empty());
if(!m_hasColorSpaces)
{
std::cerr << "OCIOLookTransform: No ColorSpaces available for input and/or output." << std::endl;
}
}
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;
}
}
OCIOColorSpace::OCIOColorSpace(Node *n) : DD::Image::PixelIop(n)
{
m_hasColorSpaces = false;
m_inputColorSpaceIndex = 0;
m_outputColorSpaceIndex = 0;
// Query the color space names from the current config
// TODO (when to) re-grab the list of available color spaces? How to save/load?
try
{
OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
OCIO::ConstColorSpaceRcPtr defaultcs = config->getColorSpace(OCIO::ROLE_SCENE_LINEAR);
if(!defaultcs) throw std::runtime_error("ROLE_SCENE_LINEAR not defined.");
std::string defaultColorSpaceName = defaultcs->getName();
for(int i = 0; i < config->getNumColorSpaces(); i++)
{
std::string csname = config->getColorSpaceNameByIndex(i);
#ifdef OCIO_CASCADE
std::string family = config->getColorSpace(csname.c_str())->getFamily();
if(family.empty())
m_colorSpaceNames.push_back(csname.c_str());
else
m_colorSpaceNames.push_back(family + "/" + csname);
#else
m_colorSpaceNames.push_back(csname);
#endif
if(csname == defaultColorSpaceName)
{
m_inputColorSpaceIndex = i;
m_outputColorSpaceIndex = i;
}
}
}
catch (OCIO::Exception& e)
{
std::cerr << "OCIOColorSpace: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "OCIOColorSpace: Unknown exception during OCIO setup." << std::endl;
}
// Then, create a cstr array for passing to Nuke
// This must be done in a second pass, lest the original m_colorSpaceNames
// std::string be reallocated in the interim
for(unsigned int i=0; i<m_colorSpaceNames.size(); ++i)
{
m_inputColorSpaceCstrNames.push_back(m_colorSpaceNames[i].c_str());
m_outputColorSpaceCstrNames.push_back(m_colorSpaceNames[i].c_str());
}
m_inputColorSpaceCstrNames.push_back(NULL);
m_outputColorSpaceCstrNames.push_back(NULL);
m_hasColorSpaces = (!m_colorSpaceNames.empty());
if(!m_hasColorSpaces)
{
std::cerr << "OCIOColorSpace: No color spaces available for input and/or output." << std::endl;
}
}