1 2class Config: 3 """ 4 Config 5 """ 6 7 def __init__(self): 8 pass 9 10 def CreateFromEnv(self): 11 """ 12 CreateFromEnv() 13 14 Create a :py:class:`PyOpenColorIO.Config` object using the environment variable. 15 16 :returns: Config object 17 """ 18 pass 19 20 def CreateFromFile(self, filename): 21 """ 22 CreateFromFile(filename) 23 24 Create a :py:class:`PyOpenColorIO.Config` object using the information in a file. 25 26 :param filename: name of file 27 :type filename: string 28 :return: Config object 29 """ 30 pass 31 32 def CreateFromStream(self, istream): 33 pass 34 35 def isEditable(self): 36 """ 37 isEditable() 38 39 Returns whether Config is editable. 40 41 The configurations returned from 42 :py:func:`PyOpenColorIO.GetCurrentConfig` are not editable, and if 43 you want to edit them you can use 44 :py:meth:`PyOpenColorIO.Config.createEditableCopy`. 45 46 If you attempt to call any of the set functions on a noneditable 47 Config, an exception will be thrown. 48 49 :return: state of :py:class:`PyOpenColorIO.Config`'s editability 50 :rtype: bool 51 """ 52 pass 53 54 def createEditableCopy(self): 55 """ 56 createEditableCopy() 57 58 Returns an editable copy of :py:class:`PyOpenColorIO.Config`. 59 60 :return: editable copy of :py:class:`PyOpenColorIO.Config` 61 :rtype: Config object 62 """ 63 pass 64 65 def sanityCheck(self): 66 """ 67 sanityCheck() 68 69 This will throw an exception if :py:class:`PyOpenColorIO.Config` is 70 malformed. The most common error occurs when references are made to 71 colorspaces that do not exist. 72 """ 73 pass 74 75 def getDescription(self): 76 """ 77 getDescription() 78 79 Returns the stored description of :py:class:`PyOpenColorIO.Config`. 80 81 :return: stored description of :py:class:`PyOpenColorIO.Config` 82 :rtype: string 83 """ 84 pass 85 86 def setDescription(self, desc): 87 """ 88 setDescription(desc) 89 90 Sets the description of :py:class:`PyOpenColorIO.Config`. 91 92 :param desc: description of :py:class:`PyOpenColorIO.Config` 93 :type desc: string 94 """ 95 pass 96 97 def serialize(self): 98 """ 99 serialize() 100 101 Returns the string representation of :py:class:`PyOpenColorIO.Config` 102 in YAML text form. This is typically stored on disk in a file with the 103 .ocio extension. 104 105 :return: :py:class:`PyOpenColorIO.Config` in YAML text form 106 :rtype: string 107 """ 108 pass 109 110 def getCacheID(self, pycontext=None): 111 """ 112 getCacheID([, pycontext]) 113 114 This will produce a hash of the all colorspace definitions, etc. 115 116 All external references, such as files used in FileTransforms, etc., 117 will be incorporated into the cacheID. While the contents of the files 118 are not read, the file system is queried for relavent information 119 (mtime, inode) so that the :py:class:`PyOpenColorIO.Config`'s cacheID 120 will change when the underlying luts are updated. 121 122 If a context is not provided, the current Context will be used. If a 123 null context is provided, file references will not be taken into 124 account (this is essentially a hash of :py:meth:`PyOpenColorIO.Config.serialize`). 125 126 :param pycontext: optional 127 :type pycontext: object 128 :return: hash of :py:class:`PyOpenColorIO.Config` 129 :rtype: string 130 """ 131 pass 132 133 def getCurrentContext(self): 134 """ 135 getCurrentContext() 136 137 Return the current context, which is essentially a record of all 138 the environment variables that are available for use in file path 139 lookups. 140 141 :return: context 142 :rtype: pycontext 143 """ 144 pass 145 146 def addEnvironmentVar(self, name, defaultValue): 147 """ 148 """ 149 pass 150 151 def getNumEnvironmentVars(self): 152 """ 153 """ 154 pass 155 156 def getEnvironmentVarNameByIndex(self, index): 157 """ 158 """ 159 pass 160 161 def getEnvironmentVarDefault(self, name): 162 """ 163 """ 164 pass 165 166 def getEnvironmentVarDefaults(self): 167 """ 168 """ 169 pass 170 171 def clearEnvironmentVars(self): 172 """ 173 """ 174 pass 175 176 def getSearchPath(self): 177 """ 178 getSearchPath() 179 180 Returns the search path. 181 182 :return: search path 183 :rtype: string 184 """ 185 pass 186 187 def setSearchPath(self, searchpath): 188 """ 189 setSearchPath(path) 190 191 Sets the search path. 192 193 :param path: the search path 194 :type path: string 195 """ 196 pass 197 198 def getWorkingDir(self): 199 """ 200 getWorkingDir() 201 202 Returns the working directory. 203 204 :return: the working directory 205 :rtype path: string 206 """ 207 pass 208 209 def setWorkingDir(self, dirname): 210 """ 211 setWorkingDir(path) 212 213 Sets the working directory. 214 215 :param path: the working directory 216 :type path: string 217 """ 218 pass 219 220 def getNumColorSpaces(self): 221 pass 222 223 def getColorSpaceNameByIndex(self, index): 224 pass 225 226 def getColorSpaces(self): 227 """ 228 getColorSpaces() 229 230 Returns all the ColorSpaces defined in :py:class:`PyOpenColorIO.Config`. 231 232 :return: ColorSpaces in :py:class:`PyOpenColorIO.Config` 233 :rtype: tuple 234 """ 235 pass 236 237 def getColorSpace(self, name): 238 """ 239 getColorSpace(name) 240 241 Returns the data for the specified color space in :py:class:`PyOpenColorIO.Config`. 242 243 This will return null if the specified name is not found. 244 245 :param name: name of color space 246 :type name: string 247 :return: data for specified color space 248 :rtype: pyColorSpace object 249 """ 250 pass 251 252 def getIndexForColorSpace(self, name): 253 pass 254 255 def addColorSpace(self, colorSpace): 256 """ 257 addColorSpace(pyColorSpace) 258 259 Add a specified color space to :py:class:`PyOpenColorIO.Config`. 260 261 :param pyColorSpace: color space 262 :type pyColorSpace: object 263 264 .. note:: 265 If another color space is already registered with the same name, 266 this will overwrite it. 267 """ 268 pass 269 270 def clearColorSpaces(self): 271 """ 272 clearColorSpaces() 273 274 Clear the color spaces in :py:class:`PyOpenColorIO.Config`. 275 """ 276 pass 277 278 def parseColorSpaceFromString(self, str): 279 """ 280 parseColorSpaceFromString(str) 281 282 Parses out the color space from a string. 283 284 Given the specified string, gets the longest, right-most color space substring. 285 * If strict parsing is enabled, and no color space is found, return an empty string. 286 * If strict parsing is disabled, return the default role, if defined. 287 * If the default role is not defined, return an empty string. 288 289 :param str: ColorSpace data 290 :type str: string 291 :return: parsed data 292 :rtype: string 293 """ 294 pass 295 296 def isStrictParsingEnabled(self): 297 pass 298 299 def setStrictParsingEnabled(self, enable): 300 pass 301 302 def setRole(self, role, csname): 303 """ 304 setRole(role, csname) 305 306 Set a role's ColorSpace. 307 308 Setting the colorSpaceName name to a null string unsets it. 309 310 :param role: role whose ColorSpace will be set 311 :type role: string 312 :param csname: name of ColorSpace 313 :type csname: string 314 """ 315 pass 316 317 def getNumRoles(self): 318 pass 319 320 def hasRole(self, role): 321 pass 322 323 def getRoleName(self, index): 324 pass 325 326 def getDefaultDisplay(self): 327 """ 328 getDefaultDisplay() 329 330 Returns the default display set in :py:class:`PyOpenColorIO.Config`. 331 332 :return: default display 333 :rtype: string 334 """ 335 pass 336 337 def getNumDisplays(self): 338 pass 339 340 def getDisplay(self, index): 341 pass 342 343 def getDisplays(self): 344 """ 345 getDisplays() 346 347 Returns all the displays defined in :py:class:`PyOpenColorIO.Config`. 348 349 :return: displays in :py:class:`PyOpenColorIO.Config` 350 :rtype: list of strings 351 """ 352 pass 353 354 def getDefaultView(self, display): 355 """ 356 getDefaultView(display) 357 358 Returns the default view of :py:class:`PyOpenColorIO.Config`. 359 360 :param display: default view 361 :type display: string 362 :return: view 363 :rtype: string 364 """ 365 pass 366 367 def getNumViews(self, display): 368 pass 369 370 def getView(self, display, index): 371 pass 372 373 def getViews(self, display): 374 """ 375 getViews(display) 376 377 Returns all the views defined in :py:class:`PyOpenColorIO.Config`. 378 379 :param display: views in :py:class:`PyOpenColorIO.Config` 380 :type display: string 381 :return: views in :py:class:`PyOpenColorIO.Config`. 382 :rtype: list of strings 383 """ 384 pass 385 386 def getDisplayColorSpaceName(self, display, view): 387 """ 388 getDisplayColorSpaceName(display, view) 389 390 Returns the ColorSpace name corresponding to the display and view 391 combination in :py:class:`PyOpenColorIO.Config`. 392 393 :param display: display 394 :type display: string 395 :param view: view 396 :type view: string 397 :return: display color space name 398 :rtype: string 399 """ 400 pass 401 402 def getDisplayLooks(self, display, view): 403 """ 404 getDisplayLooks(display, view) 405 406 Returns the looks corresponding to the display and view combination in 407 :py:class:`PyOpenColorIO.Config`. 408 409 :param display: display 410 :type display: string 411 :param view: view 412 :type view: string 413 :return: looks 414 :rtype: string 415 """ 416 pass 417 418 def addDisplay(self, display, view, csname, looks=None): 419 """ 420 addDisplay(display, view, colorSpaceName[, looks]) 421 422 NEEDS WORK 423 424 :param display: 425 :type display: string 426 :param view: 427 :type view: string 428 :param colorSpaceName: 429 :type colorSpaceName: string 430 :param looks: optional 431 :type looks: string 432 """ 433 pass 434 435 def clearDisplays(self): 436 """ 437 clearDisplays() 438 """ 439 pass 440 441 def setActiveDisplays(self, dislpays): 442 """ 443 setActiveDisplays(displays) 444 445 Sets the active displays in :py:class:`PyOpenColorIO.Config`. 446 447 :param displays: active displays 448 :type displays: string 449 """ 450 pass 451 452 def getActiveDisplays(self): 453 """ 454 getActiveDisplays() 455 456 Returns the active displays in :py:class:`PyOpenColorIO.Config`. 457 458 :return: active displays 459 :rtype: string 460 """ 461 pass 462 463 def setActiveViews(self, views): 464 """ 465 setActiveViews(views) 466 467 Sets the active views in :py:class:`PyOpenColorIO.Config`. 468 469 :param views: active views 470 :type views: string 471 """ 472 pass 473 474 def getActiveViews(self): 475 """ 476 getActiveViews() 477 478 Returns the active views in :py:class:`PyOpenColorIO.Config`. 479 480 :return: active views 481 :rtype: string 482 """ 483 pass 484 485 def getDefaultLumaCoefs(self): 486 """ 487 getDefaultLumaCoefs() 488 489 Returns the default luma coefficients in :py:class:`PyOpenColorIO.Config`. 490 491 :return: luma coefficients 492 :rtype: list of floats 493 """ 494 pass 495 496 def setDefaultLumaCoefs(self, coefficients): 497 """ 498 setDefaultLumaCoefs(pyCoef) 499 500 Sets the default luma coefficients in :py:class:`PyOpenColorIO.Config`. 501 502 :param pyCoef: luma coefficients 503 :type pyCoef: object 504 """ 505 pass 506 507 def getLook(self, lookname): 508 """ 509 getLook(str) 510 511 Returns the information of a specified look in 512 :py:class:`PyOpenColorIO.Config`. 513 514 :param str: look 515 :type str: string 516 :return: specified look 517 :rtype: look object 518 """ 519 pass 520 521 def getNumLooks(self): 522 pass 523 524 def getLookNameByIndex(self, index): 525 pass 526 527 def getLooks(self): 528 """ 529 getLooks() 530 531 Returns a list of all the looks defined in 532 :py:class:`PyOpenColorIO.Config`. 533 534 :return: looks 535 :rtype: tuple of look objects 536 """ 537 pass 538 539 def addLook(self, look): 540 """ 541 addLook(pylook) 542 543 Adds a look to :py:class:`PyOpenColorIO.Config`. 544 545 :param pylook: look 546 :type pylook: look object 547 """ 548 pass 549 550 def clearLooks(self): 551 """ 552 clearLooks() 553 554 Clear looks in :py:class:`PyOpenColorIO.Config`. 555 """ 556 pass 557 558 def getProcessor(self, arg1, arg2=None, direction=None, context=None): 559 """ 560 getProcessor(arg1[, arg2[, direction[, context]]) 561 562 Returns a processor for a specified transform. 563 564 Although this is not often needed, it allows for the reuse of atomic 565 OCIO functionality, such as applying an individual LUT file. 566 567 There are two canonical ways of creating a 568 :py:class:`PyOpenColorIO.Processor`: 569 570 #. Pass a transform into arg1, in which case arg2 will be ignored. 571 #. Set arg1 as the source and arg2 as the destination. These can be 572 ColorSpace names, objects, or roles. 573 574 Both arguments, ``direction`` (of transform) and ``context``, are 575 optional and respected for both methods of 576 :py:class:`PyOpenColorIO.Processor` creation. 577 578 This will fail if either the source or destination color space is null. 579 580 See Python: Processor for more details. 581 582 .. note:: 583 This may provide higher fidelity than anticipated due to internal 584 optimizations. For example, if inputColorSpace and outputColorSpace 585 are members of the same family, no conversion will be applied, even 586 though, strictly speaking, quantization should be added. 587 588 If you wish to test these calls for quantization characteristics, 589 apply in two steps; the image must contain RGB triples (though 590 arbitrary numbers of additional channels can be optionally 591 supported using the pixelStrideBytes arg). ??? 592 593 :param arg1: 594 :type arg1: object 595 :param arg2: ignored if arg1 is a transform 596 :type arg2: object 597 :param direction: optional 598 :type direction: string 599 :param context: optional 600 :type context: object 601 """ 602 pass 603