/src/pyglue/PyColorSpace.cpp

http://github.com/imageworks/OpenColorIO · C++ · 477 lines · 395 code · 47 blank · 35 comment · 24 complexity · 4e6c4cc627c5083bb82d348a16ab9c06 MD5 · raw file

  1. /*
  2. Copyright (c) 2003-2010 Sony Pictures Imageworks Inc., et al.
  3. All Rights Reserved.
  4. Redistribution and use in source and binary forms, with or without
  5. modification, are permitted provided that the following conditions are
  6. met:
  7. * Redistributions of source code must retain the above copyright
  8. notice, this list of conditions and the following disclaimer.
  9. * Redistributions in binary form must reproduce the above copyright
  10. notice, this list of conditions and the following disclaimer in the
  11. documentation and/or other materials provided with the distribution.
  12. * Neither the name of Sony Pictures Imageworks nor the names of its
  13. contributors may be used to endorse or promote products derived from
  14. this software without specific prior written permission.
  15. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16. "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17. LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18. A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19. OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20. SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21. LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22. DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23. THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. #include <Python.h>
  28. #include <OpenColorIO/OpenColorIO.h>
  29. #include "PyUtil.h"
  30. #include "PyDoc.h"
  31. OCIO_NAMESPACE_ENTER
  32. {
  33. PyObject * BuildConstPyColorSpace(ConstColorSpaceRcPtr colorSpace)
  34. {
  35. return BuildConstPyOCIO<PyOCIO_ColorSpace, ColorSpaceRcPtr,
  36. ConstColorSpaceRcPtr>(colorSpace, PyOCIO_ColorSpaceType);
  37. }
  38. PyObject * BuildEditablePyColorSpace(ColorSpaceRcPtr colorSpace)
  39. {
  40. return BuildEditablePyOCIO<PyOCIO_ColorSpace, ColorSpaceRcPtr,
  41. ConstColorSpaceRcPtr>(colorSpace, PyOCIO_ColorSpaceType);
  42. }
  43. bool IsPyColorSpace(PyObject * pyobject)
  44. {
  45. return IsPyOCIOType(pyobject, PyOCIO_ColorSpaceType);
  46. }
  47. bool IsPyColorSpaceEditable(PyObject * pyobject)
  48. {
  49. return IsPyEditable<PyOCIO_ColorSpace>(pyobject, PyOCIO_ColorSpaceType);
  50. }
  51. ConstColorSpaceRcPtr GetConstColorSpace(PyObject * pyobject, bool allowCast)
  52. {
  53. return GetConstPyOCIO<PyOCIO_ColorSpace, ConstColorSpaceRcPtr>(pyobject,
  54. PyOCIO_ColorSpaceType, allowCast);
  55. }
  56. ColorSpaceRcPtr GetEditableColorSpace(PyObject * pyobject)
  57. {
  58. return GetEditablePyOCIO<PyOCIO_ColorSpace, ColorSpaceRcPtr>(pyobject,
  59. PyOCIO_ColorSpaceType);
  60. }
  61. namespace
  62. {
  63. ///////////////////////////////////////////////////////////////////////
  64. ///
  65. int PyOCIO_ColorSpace_init(PyOCIO_ColorSpace * self, PyObject * args, PyObject * kwds);
  66. void PyOCIO_ColorSpace_delete(PyOCIO_ColorSpace * self, PyObject * args);
  67. PyObject * PyOCIO_ColorSpace_isEditable(PyObject * self);
  68. PyObject * PyOCIO_ColorSpace_createEditableCopy(PyObject * self);
  69. PyObject * PyOCIO_ColorSpace_getName(PyObject * self);
  70. PyObject * PyOCIO_ColorSpace_setName(PyObject * self, PyObject * args);
  71. PyObject * PyOCIO_ColorSpace_getFamily(PyObject * self);
  72. PyObject * PyOCIO_ColorSpace_setFamily(PyObject * self, PyObject * args);
  73. PyObject * PyOCIO_ColorSpace_getEqualityGroup(PyObject * self);
  74. PyObject * PyOCIO_ColorSpace_setEqualityGroup(PyObject * self, PyObject * args);
  75. PyObject * PyOCIO_ColorSpace_getDescription(PyObject * self);
  76. PyObject * PyOCIO_ColorSpace_setDescription(PyObject * self, PyObject * args);
  77. PyObject * PyOCIO_ColorSpace_getBitDepth(PyObject * self);
  78. PyObject * PyOCIO_ColorSpace_setBitDepth(PyObject * self, PyObject * args);
  79. PyObject * PyOCIO_ColorSpace_isData(PyObject * self);
  80. PyObject * PyOCIO_ColorSpace_setIsData(PyObject * self, PyObject * args);
  81. PyObject * PyOCIO_ColorSpace_getAllocation(PyObject * self);
  82. PyObject * PyOCIO_ColorSpace_setAllocation(PyObject * self, PyObject * args );
  83. PyObject * PyOCIO_ColorSpace_getAllocationVars(PyObject * self);
  84. PyObject * PyOCIO_ColorSpace_setAllocationVars(PyObject * self, PyObject * args);
  85. PyObject * PyOCIO_ColorSpace_getTransform(PyObject * self, PyObject * args);
  86. PyObject * PyOCIO_ColorSpace_setTransform(PyObject * self, PyObject * args);
  87. ///////////////////////////////////////////////////////////////////////
  88. ///
  89. PyMethodDef PyOCIO_ColorSpace_methods[] = {
  90. { "isEditable",
  91. (PyCFunction) PyOCIO_ColorSpace_isEditable, METH_NOARGS, COLORSPACE_ISEDITABLE__DOC__ },
  92. { "createEditableCopy",
  93. (PyCFunction) PyOCIO_ColorSpace_createEditableCopy, METH_NOARGS, COLORSPACE_CREATEEDITABLECOPY__DOC__ },
  94. { "getName",
  95. (PyCFunction) PyOCIO_ColorSpace_getName, METH_NOARGS, COLORSPACE_GETNAME__DOC__ },
  96. { "setName",
  97. PyOCIO_ColorSpace_setName, METH_VARARGS, COLORSPACE_SETNAME__DOC__ },
  98. { "getFamily",
  99. (PyCFunction) PyOCIO_ColorSpace_getFamily, METH_NOARGS, COLORSPACE_GETFAMILY__DOC__ },
  100. { "setFamily",
  101. PyOCIO_ColorSpace_setFamily, METH_VARARGS, COLORSPACE_SETFAMILY__DOC__ },
  102. { "getEqualityGroup",
  103. (PyCFunction) PyOCIO_ColorSpace_getEqualityGroup, METH_NOARGS, COLORSPACE_GETEQUALITYGROUP__DOC__ },
  104. { "setEqualityGroup",
  105. PyOCIO_ColorSpace_setEqualityGroup, METH_VARARGS, COLORSPACE_SETEQUALITYGROUP__DOC__ },
  106. { "getDescription",
  107. (PyCFunction) PyOCIO_ColorSpace_getDescription, METH_NOARGS, COLORSPACE_GETDESCRIPTION__DOC__ },
  108. { "setDescription",
  109. PyOCIO_ColorSpace_setDescription, METH_VARARGS, COLORSPACE_SETDESCRIPTION__DOC__ },
  110. { "getBitDepth",
  111. (PyCFunction) PyOCIO_ColorSpace_getBitDepth, METH_NOARGS, COLORSPACE_GETBITDEPTH__DOC__ },
  112. { "setBitDepth",
  113. PyOCIO_ColorSpace_setBitDepth, METH_VARARGS, COLORSPACE_SETBITDEPTH__DOC__ },
  114. { "isData",
  115. (PyCFunction) PyOCIO_ColorSpace_isData, METH_NOARGS, COLORSPACE_ISDATA__DOC__ },
  116. { "setIsData",
  117. PyOCIO_ColorSpace_setIsData, METH_VARARGS, COLORSPACE_SETISDATA__DOC__ },
  118. { "getAllocation",
  119. (PyCFunction) PyOCIO_ColorSpace_getAllocation, METH_NOARGS, COLORSPACE_GETALLOCATION__DOC__ },
  120. { "setAllocation",
  121. PyOCIO_ColorSpace_setAllocation, METH_VARARGS, COLORSPACE_SETALLOCATION__DOC__ },
  122. { "getAllocationVars",
  123. (PyCFunction) PyOCIO_ColorSpace_getAllocationVars, METH_NOARGS, COLORSPACE_GETALLOCATIONVARS__DOC__ },
  124. { "setAllocationVars",
  125. PyOCIO_ColorSpace_setAllocationVars, METH_VARARGS, COLORSPACE_SETALLOCATIONVARS__DOC__ },
  126. { "getTransform",
  127. PyOCIO_ColorSpace_getTransform, METH_VARARGS, COLORSPACE_GETTRANSFORM__DOC__ },
  128. { "setTransform",
  129. PyOCIO_ColorSpace_setTransform, METH_VARARGS, COLORSPACE_SETTRANSFORM__DOC__ },
  130. { NULL, NULL, 0, NULL }
  131. };
  132. }
  133. ///////////////////////////////////////////////////////////////////////////
  134. ///
  135. PyTypeObject PyOCIO_ColorSpaceType = {
  136. PyVarObject_HEAD_INIT(NULL, 0) //ob_size
  137. "OCIO.ColorSpace", //tp_name
  138. sizeof(PyOCIO_ColorSpace), //tp_basicsize
  139. 0, //tp_itemsize
  140. (destructor)PyOCIO_ColorSpace_delete, //tp_dealloc
  141. 0, //tp_print
  142. 0, //tp_getattr
  143. 0, //tp_setattr
  144. 0, //tp_compare
  145. 0, //tp_repr
  146. 0, //tp_as_number
  147. 0, //tp_as_sequence
  148. 0, //tp_as_mapping
  149. 0, //tp_hash
  150. 0, //tp_call
  151. 0, //tp_str
  152. 0, //tp_getattro
  153. 0, //tp_setattro
  154. 0, //tp_as_buffer
  155. Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, //tp_flags
  156. COLORSPACE__DOC__, //tp_doc
  157. 0, //tp_traverse
  158. 0, //tp_clear
  159. 0, //tp_richcompare
  160. 0, //tp_weaklistoffset
  161. 0, //tp_iter
  162. 0, //tp_iternext
  163. PyOCIO_ColorSpace_methods, //tp_methods
  164. 0, //tp_members
  165. 0, //tp_getset
  166. 0, //tp_base
  167. 0, //tp_dict
  168. 0, //tp_descr_get
  169. 0, //tp_descr_set
  170. 0, //tp_dictoffset
  171. (initproc) PyOCIO_ColorSpace_init, //tp_init
  172. 0, //tp_alloc
  173. 0, //tp_new
  174. 0, //tp_free
  175. 0, //tp_is_gc
  176. };
  177. namespace
  178. {
  179. ///////////////////////////////////////////////////////////////////////
  180. ///
  181. int PyOCIO_ColorSpace_init(PyOCIO_ColorSpace * self, PyObject * args, PyObject * kwds)
  182. {
  183. OCIO_PYTRY_ENTER()
  184. ColorSpaceRcPtr ptr = ColorSpace::Create();
  185. int ret = BuildPyObject<PyOCIO_ColorSpace, ConstColorSpaceRcPtr, ColorSpaceRcPtr>(self, ptr);
  186. char* name = NULL;
  187. char* family = NULL;
  188. char* equalityGroup = NULL;
  189. char* description = NULL;
  190. char* bitDepth = NULL;
  191. bool isData = false; // TODO: Do not rely on the default value
  192. char* allocation = NULL;
  193. PyObject* allocationVars = NULL;
  194. PyObject* toRefTransform = NULL;
  195. PyObject* fromRefTransform = NULL;
  196. const char* toRefStr =
  197. ColorSpaceDirectionToString(COLORSPACE_DIR_TO_REFERENCE);
  198. const char* fromRefStr =
  199. ColorSpaceDirectionToString(COLORSPACE_DIR_FROM_REFERENCE);
  200. const char* kwlist[] = { "name", "family", "equalityGroup",
  201. "description", "bitDepth", "isData", "allocation",
  202. "allocationVars", toRefStr, fromRefStr, NULL };
  203. if(!PyArg_ParseTupleAndKeywords(args, kwds, "|sssssO&sOOO",
  204. const_cast<char **>(kwlist),
  205. &name, &family, &equalityGroup, &description, &bitDepth,
  206. ConvertPyObjectToBool, &isData,
  207. &allocation, &allocationVars,
  208. &toRefTransform, &fromRefTransform)) return -1;
  209. if(name) ptr->setName(name);
  210. if(family) ptr->setFamily(family);
  211. if(equalityGroup) ptr->setEqualityGroup(equalityGroup);
  212. if(description) ptr->setDescription(description);
  213. if(bitDepth) ptr->setBitDepth(BitDepthFromString(bitDepth));
  214. ptr->setIsData(isData); // TODO: Do not rely on the default value
  215. if(allocation) ptr->setAllocation(AllocationFromString(allocation));
  216. if(allocationVars)
  217. {
  218. std::vector<float> vars;
  219. if(!FillFloatVectorFromPySequence(allocationVars, vars))
  220. {
  221. PyErr_SetString(PyExc_TypeError, "allocationVars kwarg must be a float array.");
  222. return -1;
  223. }
  224. ptr->setAllocationVars(static_cast<int>(vars.size()), &vars[0]);
  225. }
  226. if(toRefTransform)
  227. {
  228. ConstTransformRcPtr transform = GetConstTransform(toRefTransform, true);
  229. ptr->setTransform(transform, COLORSPACE_DIR_TO_REFERENCE);
  230. }
  231. if(fromRefTransform)
  232. {
  233. ConstTransformRcPtr transform = GetConstTransform(fromRefTransform, true);
  234. ptr->setTransform(transform, COLORSPACE_DIR_FROM_REFERENCE);
  235. }
  236. return ret;
  237. OCIO_PYTRY_EXIT(-1)
  238. }
  239. void PyOCIO_ColorSpace_delete(PyOCIO_ColorSpace *self, PyObject * /*args*/)
  240. {
  241. DeletePyObject<PyOCIO_ColorSpace>(self);
  242. }
  243. PyObject * PyOCIO_ColorSpace_isEditable(PyObject * self)
  244. {
  245. return PyBool_FromLong(IsPyColorSpaceEditable(self));
  246. }
  247. PyObject * PyOCIO_ColorSpace_createEditableCopy(PyObject * self)
  248. {
  249. OCIO_PYTRY_ENTER()
  250. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  251. ColorSpaceRcPtr copy = colorSpace->createEditableCopy();
  252. return BuildEditablePyColorSpace(copy);
  253. OCIO_PYTRY_EXIT(NULL)
  254. }
  255. PyObject * PyOCIO_ColorSpace_getName(PyObject * self)
  256. {
  257. OCIO_PYTRY_ENTER()
  258. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  259. return PyString_FromString(colorSpace->getName());
  260. OCIO_PYTRY_EXIT(NULL)
  261. }
  262. PyObject * PyOCIO_ColorSpace_setName(PyObject * self, PyObject * args)
  263. {
  264. OCIO_PYTRY_ENTER()
  265. char* name = 0;
  266. if (!PyArg_ParseTuple(args, "s:setName", &name)) return NULL;
  267. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  268. colorSpace->setName(name);
  269. Py_RETURN_NONE;
  270. OCIO_PYTRY_EXIT(NULL)
  271. }
  272. PyObject * PyOCIO_ColorSpace_getFamily(PyObject * self)
  273. {
  274. OCIO_PYTRY_ENTER()
  275. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  276. return PyString_FromString(colorSpace->getFamily());
  277. OCIO_PYTRY_EXIT(NULL)
  278. }
  279. PyObject * PyOCIO_ColorSpace_setFamily(PyObject * self, PyObject * args)
  280. {
  281. OCIO_PYTRY_ENTER()
  282. char* name = 0;
  283. if (!PyArg_ParseTuple(args, "s:setFamily", &name)) return NULL;
  284. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  285. colorSpace->setFamily(name);
  286. Py_RETURN_NONE;
  287. OCIO_PYTRY_EXIT(NULL)
  288. }
  289. PyObject * PyOCIO_ColorSpace_getEqualityGroup(PyObject * self)
  290. {
  291. OCIO_PYTRY_ENTER()
  292. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  293. return PyString_FromString(colorSpace->getEqualityGroup());
  294. OCIO_PYTRY_EXIT(NULL)
  295. }
  296. PyObject * PyOCIO_ColorSpace_setEqualityGroup(PyObject * self, PyObject * args)
  297. {
  298. OCIO_PYTRY_ENTER()
  299. char* name = 0;
  300. if (!PyArg_ParseTuple(args, "s:setEqualityGroup", &name)) return NULL;
  301. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  302. colorSpace->setEqualityGroup(name);
  303. Py_RETURN_NONE;
  304. OCIO_PYTRY_EXIT(NULL)
  305. }
  306. PyObject * PyOCIO_ColorSpace_getDescription(PyObject * self)
  307. {
  308. OCIO_PYTRY_ENTER()
  309. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  310. return PyString_FromString(colorSpace->getDescription());
  311. OCIO_PYTRY_EXIT(NULL)
  312. }
  313. PyObject * PyOCIO_ColorSpace_setDescription(PyObject * self, PyObject * args)
  314. {
  315. OCIO_PYTRY_ENTER()
  316. char* name = 0;
  317. if (!PyArg_ParseTuple(args, "s:setDescription", &name)) return NULL;
  318. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  319. colorSpace->setDescription(name);
  320. Py_RETURN_NONE;
  321. OCIO_PYTRY_EXIT(NULL)
  322. }
  323. PyObject * PyOCIO_ColorSpace_getBitDepth(PyObject * self)
  324. {
  325. OCIO_PYTRY_ENTER()
  326. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  327. return PyString_FromString( BitDepthToString(colorSpace->getBitDepth()));
  328. OCIO_PYTRY_EXIT(NULL)
  329. }
  330. PyObject * PyOCIO_ColorSpace_setBitDepth(PyObject * self, PyObject * args)
  331. {
  332. OCIO_PYTRY_ENTER()
  333. char* name = 0;
  334. if (!PyArg_ParseTuple(args, "s:setBitDepth", &name)) return NULL;
  335. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  336. colorSpace->setBitDepth(BitDepthFromString(name));
  337. Py_RETURN_NONE;
  338. OCIO_PYTRY_EXIT(NULL)
  339. }
  340. PyObject * PyOCIO_ColorSpace_isData(PyObject * self)
  341. {
  342. OCIO_PYTRY_ENTER()
  343. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  344. return PyBool_FromLong(colorSpace->isData());
  345. OCIO_PYTRY_EXIT(NULL)
  346. }
  347. PyObject * PyOCIO_ColorSpace_setIsData(PyObject * self, PyObject * args)
  348. {
  349. OCIO_PYTRY_ENTER()
  350. bool isData = false;
  351. if (!PyArg_ParseTuple(args, "O&:setIsData",
  352. ConvertPyObjectToBool, &isData)) return NULL;
  353. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  354. colorSpace->setIsData(isData);
  355. Py_RETURN_NONE;
  356. OCIO_PYTRY_EXIT(NULL)
  357. }
  358. PyObject * PyOCIO_ColorSpace_getAllocation(PyObject * self)
  359. {
  360. OCIO_PYTRY_ENTER()
  361. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  362. return PyString_FromString(AllocationToString(colorSpace->getAllocation()));
  363. OCIO_PYTRY_EXIT(NULL)
  364. }
  365. PyObject * PyOCIO_ColorSpace_setAllocation(PyObject * self, PyObject * args)
  366. {
  367. OCIO_PYTRY_ENTER()
  368. Allocation hwalloc;
  369. if (!PyArg_ParseTuple(args, "O&:setAllocation",
  370. ConvertPyObjectToAllocation, &hwalloc)) return NULL;
  371. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  372. colorSpace->setAllocation(hwalloc);
  373. Py_RETURN_NONE;
  374. OCIO_PYTRY_EXIT(NULL)
  375. }
  376. PyObject * PyOCIO_ColorSpace_getAllocationVars(PyObject * self)
  377. {
  378. OCIO_PYTRY_ENTER()
  379. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  380. std::vector<float> allocationvars(colorSpace->getAllocationNumVars());
  381. if(!allocationvars.empty())
  382. colorSpace->getAllocationVars(&allocationvars[0]);
  383. return CreatePyListFromFloatVector(allocationvars);
  384. OCIO_PYTRY_EXIT(NULL)
  385. }
  386. PyObject * PyOCIO_ColorSpace_setAllocationVars(PyObject * self, PyObject * args)
  387. {
  388. OCIO_PYTRY_ENTER()
  389. PyObject* pyvars = 0;
  390. if (!PyArg_ParseTuple(args, "O:setAllocationVars", &pyvars)) return NULL;
  391. std::vector<float> vars;
  392. if(!FillFloatVectorFromPySequence(pyvars, vars))
  393. {
  394. PyErr_SetString(PyExc_TypeError, "First argument must be a float array.");
  395. return 0;
  396. }
  397. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  398. if(!vars.empty())
  399. colorSpace->setAllocationVars(static_cast<int>(vars.size()), &vars[0]);
  400. Py_RETURN_NONE;
  401. OCIO_PYTRY_EXIT(NULL)
  402. }
  403. PyObject * PyOCIO_ColorSpace_getTransform(PyObject * self, PyObject * args)
  404. {
  405. OCIO_PYTRY_ENTER()
  406. ColorSpaceDirection dir;
  407. if (!PyArg_ParseTuple(args, "O&:getTransform",
  408. ConvertPyObjectToColorSpaceDirection, &dir)) return NULL;
  409. ConstColorSpaceRcPtr colorSpace = GetConstColorSpace(self, true);
  410. ConstTransformRcPtr transform = colorSpace->getTransform(dir);
  411. return BuildConstPyTransform(transform);
  412. OCIO_PYTRY_EXIT(NULL)
  413. }
  414. PyObject * PyOCIO_ColorSpace_setTransform(PyObject * self, PyObject * args)
  415. {
  416. OCIO_PYTRY_ENTER()
  417. PyObject* pytransform = 0;
  418. ColorSpaceDirection dir;
  419. if (!PyArg_ParseTuple(args, "OO&:setTransform", &pytransform,
  420. ConvertPyObjectToColorSpaceDirection, &dir)) return NULL;
  421. ConstTransformRcPtr transform = GetConstTransform(pytransform, true);
  422. ColorSpaceRcPtr colorSpace = GetEditableColorSpace(self);
  423. colorSpace->setTransform(transform, dir);
  424. Py_RETURN_NONE;
  425. OCIO_PYTRY_EXIT(NULL)
  426. }
  427. }
  428. }
  429. OCIO_NAMESPACE_EXIT