// 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 }
TypeDesc ColorConfig::getColorSpaceDataType (string_view name, int *bits) const { #ifdef USE_OCIO OCIO::ConstColorSpaceRcPtr c = getImpl()->config_->getColorSpace (name.c_str()); if (c) { OCIO::BitDepth b = c->getBitDepth(); switch (b) { case OCIO::BIT_DEPTH_UNKNOWN : return TypeDesc::UNKNOWN; case OCIO::BIT_DEPTH_UINT8 : *bits = 8; return TypeDesc::UINT8; case OCIO::BIT_DEPTH_UINT10 : *bits = 10; return TypeDesc::UINT16; case OCIO::BIT_DEPTH_UINT12 : *bits = 12; return TypeDesc::UINT16; case OCIO::BIT_DEPTH_UINT14 : *bits = 14; return TypeDesc::UINT16; case OCIO::BIT_DEPTH_UINT16 : *bits = 16; return TypeDesc::UINT16; case OCIO::BIT_DEPTH_UINT32 : *bits = 32; return TypeDesc::UINT32; case OCIO::BIT_DEPTH_F16 : *bits = 16; return TypeDesc::HALF; case OCIO::BIT_DEPTH_F32 : *bits = 32; return TypeDesc::FLOAT; } } #endif return TypeDesc::UNKNOWN; }
// 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); }
bool ColorSpaceManager::colorspace_is_data(ustring colorspace) { if (colorspace == u_colorspace_auto || colorspace == u_colorspace_raw || colorspace == u_colorspace_srgb) { return false; } #ifdef WITH_OCIO OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig(); if (!config) { return false; } try { OCIO::ConstColorSpaceRcPtr space = config->getColorSpace(colorspace.c_str()); return space && space->isData(); } catch (OCIO::Exception &) { return false; } #else return false; #endif }
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 }
static void buildChoiceMenu(OCIO::ConstConfigRcPtr config, ChoiceParamType* choice, bool cascading, const std::string& name = "") { #ifdef DEBUG //printf("%p->resetOptions\n", (void*)choice); #endif choice->resetOptions(); assert(choice->getNOptions() == 0); if (!config) { return; } int def = -1; 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) { std::string csname = config->getColorSpaceNameByIndex(i); std::string msg; // set the default value, in case the GUI uses it if (!name.empty() && csname == name) { def = i; } OCIO_NAMESPACE::ConstColorSpaceRcPtr cs = config->getColorSpace(csname.c_str()); if (cascading) { std::string family = config->getColorSpace(csname.c_str())->getFamily(); if (!family.empty()) { csname = family + "/" + csname; } } std::string csdesc = cs ? cs->getDescription() : "(no colorspace)"; csdesc = whitespacify(trim(csdesc)); int csdesclen = csdesc.size(); if ( csdesclen > 0 ) { msg += csdesc; } 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 (roles > 0) { msg += ')'; } #ifdef DEBUG //printf("%p->appendOption(\"%s\",\"%s\") (%d->%d options)\n", (void*)choice, csname.c_str(), msg.c_str(), i, i+1); #endif assert(choice->getNOptions() == i); choice->appendOption(csname, msg); assert(choice->getNOptions() == i+1); } if (def != -1) { choice->setDefault(def); } }
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; } }
static void PopulateOCIOMenus() { OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig(); int csMenuID = glutCreateMenu(imageColorSpace_CB); std::map<std::string, int> families; for(int i=0; i<config->getNumColorSpaces(); ++i) { const char * csName = config->getColorSpaceNameByIndex(i); if(csName && *csName) { OCIO::ConstColorSpaceRcPtr cs = config->getColorSpace(csName); if(cs) { const char * family = cs->getFamily(); if(family && *family) { if(families.find(family)==families.end()) { families[family] = glutCreateMenu(imageColorSpace_CB); glutAddMenuEntry(csName, i); glutSetMenu(csMenuID); glutAddSubMenu(family, families[family]); } else { glutSetMenu(families[family]); glutAddMenuEntry(csName, i); } } else { glutSetMenu(csMenuID); glutAddMenuEntry(csName, i); } } } } int deviceMenuID = glutCreateMenu(displayDevice_CB); for(int i=0; i<config->getNumDisplays(); ++i) { glutAddMenuEntry(config->getDisplay(i), i); } int transformMenuID = glutCreateMenu(transform_CB); const char * defaultDisplay = config->getDefaultDisplay(); for(int i=0; i<config->getNumViews(defaultDisplay); ++i) { glutAddMenuEntry(config->getView(defaultDisplay, i), i); } int lookMenuID = glutCreateMenu(look_CB); for(int i=0; i<config->getNumLooks(); ++i) { glutAddMenuEntry(config->getLookNameByIndex(i), i); } glutCreateMenu(menuCallback); glutAddSubMenu("Image ColorSpace", csMenuID); glutAddSubMenu("Transform", transformMenuID); glutAddSubMenu("Device", deviceMenuID); glutAddSubMenu("Looks Override", lookMenuID); glutAttachMenu(GLUT_RIGHT_BUTTON); }
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; } }