// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off // // This .C file was turned into a header file so that instantiations // of the various V3* types can be spread across multiple files in // order to work around MSVC limitations. // #include #define BOOST_BIND_GLOBAL_PLACEHOLDERS #include #include #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathColor.h" #include "PyImathVec.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathColor3ArrayImpl.h" namespace PyImath { template <> const char *PyImath::C3cArray::name() { return "C3cArray"; } template <> const char *PyImath::C3fArray::name() { return "C3fArray"; } using namespace boost::python; using namespace IMATH_NAMESPACE; template struct Color3Name { static const char *value; }; template<> const char *Color3Name::value = "Color3c"; template<> const char *Color3Name::value = "Color3f"; // create a new default constructor that initializes Color3 to zero. template static Color3 * Color3_construct_default() { return new Color3(T(0),T(0),T(0)); } template static Color3 * Color3_component_construct1(S x, S y, S z) { // Assigning a floating point value to an integer type can cause a // float-point error, which we want to translate into an exception. MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) x; unsigned char g = (unsigned char) y; unsigned char b = (unsigned char) z; return new Color3(r,g,b); } else return new Color3(T (x), T(y), T(z)); } template static Color3 * Color3_component_construct2(S x) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char u = (unsigned char) x; return new Color3(u,u,u); } else return new Color3(T(x), T(x), T(x)); } template static Color3 * Color3_color_construct(const Color3 &c) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) c.x; unsigned char g = (unsigned char) c.y; unsigned char b = (unsigned char) c.z; return new Color3(r,g,b); } else return new Color3(T (c.x), T(c.y), T(c.z)); } template static Color3 * Color3_vector_construct(const Vec3 &c) { MATH_EXC_ON; if(strcmp(Color3Name::value, "Color3c") == 0) { unsigned char r = (unsigned char) c.x; unsigned char g = (unsigned char) c.y; unsigned char b = (unsigned char) c.z; return new Color3(r,g,b); } else return new Color3(T (c.x), T(c.y), T(c.z)); } template static std::string color3_str(const Color3 &v) { std::stringstream stream; if(strcmp(Color3Name::value, "Color3c") == 0) { int r = int(v.x); int g = int(v.y); int b = int(v.z); stream << Color3Name::value << "(" << r << ", " << g << ", " << b << ")"; return stream.str(); } else { stream << Color3Name::value << "(" << v.x << ", " << v.y << ", " << v.z << ")"; return stream.str(); } } // Non-specialized repr is same as str template static std::string color3_repr(const Color3 &v) { return color3_str(v); } // Specialization for float to full precision template <> std::string color3_repr(const Color3 &v) { return (boost::format("%s(%.9g, %.9g, %.9g)") % Color3Name::value % v.x % v.y % v.z).str(); } // No specialization for double, since we don't instantiate Color3d template static Color3 * Color3_construct_tuple(const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) { return new Color3(extract(t[0]), extract(t[1]), extract(t[2])); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 * Color3_construct_list(const list &l) { MATH_EXC_ON; if(l.attr("__len__")() == 3) { return new Color3(extract(l[0]), extract(l[1]), extract(l[2])); } else throw std::invalid_argument ("Color3 expects list of length 3"); } template static const Color3 & iadd(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color += color2; } template static Color3 add(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color + color2; } template static Color3 addTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x + extract(t[0]), color.y + extract(t[1]), color.z + extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 addT(Color3 &v, T a) { MATH_EXC_ON; Color3 w(v.x + a, v.y + a, v.z + a); return w; } template static const Color3 & isub(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color -= color2; } template static Color3 sub(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color - color2; } template static Color3 subtractL(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x - extract(t[0]), color.y - extract(t[1]), color.z - extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 subtractLT(const Color3 &color, T a) { MATH_EXC_ON; return Color3(color.x - a, color.y - a, color.z - a); } template static Color3 subtractRT(const Color3 &color, T a) { MATH_EXC_ON; return Color3(a - color.x, a - color.y, a - color.z); } template static Color3 subtractR(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(extract(t[0]) - color.x, extract(t[1]) - color.y, extract(t[2]) - color.z); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 neg(Color3 &color) { MATH_EXC_ON; return -color; } template static const Color3 & negate(Color3 &color) { MATH_EXC_ON; return color.negate(); } template static const Color3 & imul(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color *= color2; } template static const Color3 & imulT(Color3 &color, const T &t) { MATH_EXC_ON; return color *= t; } template static Color3 mul(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color * color2; } template static Color3 mulT(Color3 &color, const T &t) { MATH_EXC_ON; return color * t; } template static Color3 rmulT(Color3 &color, const T &t) { MATH_EXC_ON; return t * color; } template static Color3 mulTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x * extract(t[0]), color.y * extract(t[1]), color.z * extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static const Color3 & idiv(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color /= color2; } template static const Color3 & idivT(Color3 &color, const T &t) { MATH_EXC_ON; return color /= t; } template static Color3 div(Color3 &color, const Color3 &color2) { MATH_EXC_ON; return color / color2; } template static Color3 divT(Color3 &color, const T &t) { MATH_EXC_ON; return color / t; } template static Color3 divTupleL(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(color.x / extract(t[0]), color.y / extract(t[1]), color.z / extract(t[2])); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 divTupleR(Color3 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 3) return Color3(extract(t[0]) / color.x, extract(t[1]) / color.y, extract(t[2]) / color.z); else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 divTR(Color3 &color, T a) { MATH_EXC_ON; return Color3(a / color.x, a / color.y, a / color.z); } template static Color3 hsv2rgb(Color3 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::hsv2rgb(color); } template static Color3 hsv2rgbTuple(const tuple &t) { MATH_EXC_ON; Color3 color; if(t.attr("__len__")() == 3) { color.x = extract(t[0]); color.y = extract(t[1]); color.z = extract(t[2]); return IMATH_NAMESPACE::hsv2rgb(color); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static Color3 rgb2hsv(Color3 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::rgb2hsv(color); } template static Color3 rgb2hsvTuple(const tuple &t) { MATH_EXC_ON; Color3 color; if(t.attr("__len__")() == 3) { color.x = extract(t[0]); color.y = extract(t[1]); color.z = extract(t[2]); return IMATH_NAMESPACE::rgb2hsv(color); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static void setValue1(Color3 &color, const T &a, const T &b, const T &c) { MATH_EXC_ON; color.setValue(a, b, c); } template static void setValue2(Color3 &color, const Color3 &v) { MATH_EXC_ON; color.setValue(v); } template static void setValueTuple(Color3 &color, const tuple &t) { MATH_EXC_ON; Color3 v; if(t.attr("__len__")() == 3) { v.x = extract(t[0]); v.y = extract(t[1]); v.z = extract(t[2]); color.setValue(v); } else throw std::invalid_argument ("Color3 expects tuple of length 3"); } template static bool lessThan(Color3 &v, const Color3 &w) { bool isLessThan = (v.x <= w.x && v.y <= w.y && v.z <= w.z) && v != w; return isLessThan; } template static bool greaterThan(Color3 &v, const Color3 &w) { bool isGreaterThan = (v.x >= w.x && v.y >= w.y && v.z >= w.z) && v != w; return isGreaterThan; } template static bool lessThanEqual(Color3 &v, const Color3 &w) { bool isLessThanEqual = (v.x <= w.x && v.y <= w.y && v.z <= w.z); return isLessThanEqual; } template static bool greaterThanEqual(Color3 &v, const Color3 &w) { bool isGreaterThanEqual = (v.x >= w.x && v.y >= w.y && v.z >= w.z); return isGreaterThanEqual; } template class_, bases > > register_Color3() { class_, bases > > color3_class(Color3Name::value, Color3Name::value,init >("copy construction")); color3_class .def("__init__",make_constructor(Color3_construct_default),"initialize to (0,0,0)") .def("__init__",make_constructor(Color3_construct_tuple), "initialize to (r,g,b) with a python tuple") .def("__init__",make_constructor(Color3_construct_list), "initialize to (r,g,b) with a python list") .def("__init__",make_constructor(Color3_component_construct1)) .def("__init__",make_constructor(Color3_component_construct1)) .def("__init__",make_constructor(Color3_component_construct2)) .def("__init__",make_constructor(Color3_component_construct2)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_color_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def("__init__",make_constructor(Color3_vector_construct)) .def_readwrite("r", &Color3::x) .def_readwrite("g", &Color3::y) .def_readwrite("b", &Color3::z) .def("__str__", &color3_str) .def("__repr__", &color3_repr) .def(self == self) // NOSONAR - suppress SonarCloud bug report. .def(self != self) // NOSONAR - suppress SonarCloud bug report. .def("__iadd__", &iadd,return_internal_reference<>()) .def("__add__", &add) .def("__add__", &addTuple) .def("__add__", &addT) .def("__radd__", &addTuple) .def("__radd__", &addT) .def("__isub__", &isub,return_internal_reference<>()) .def("__sub__", &sub) .def("__sub__", &subtractL) .def("__sub__", &subtractLT) .def("__rsub__", &subtractR) .def("__rsub__", &subtractRT) .def("__neg__", &neg) .def("negate",&negate,return_internal_reference<>(),"component-wise multiplication by -1") .def("__imul__", &imul,return_internal_reference<>()) .def("__imul__", &imulT,return_internal_reference<>()) .def("__mul__", &mul) .def("__mul__", &mulT) .def("__rmul__", &rmulT) .def("__mul__", &mulTuple) .def("__rmul__", &mulTuple) .def("__idiv__", &idiv,return_internal_reference<>()) .def("__idiv__", &idivT,return_internal_reference<>()) .def("__itruediv__", &idiv,return_internal_reference<>()) .def("__itruediv__", &idivT,return_internal_reference<>()) .def("__div__", &div) .def("__div__", &divT) .def("__div__", &divTupleL) .def("__truediv__", &div) .def("__truediv__", &divT) .def("__truediv__", &divTupleL) .def("__rdiv__", &divTupleR) .def("__rdiv__", &divTR) .def("__rtruediv__", &divTupleR) .def("__rtruediv__", &divTR) .def("__lt__", &lessThan) .def("__gt__", &greaterThan) .def("__le__", &lessThanEqual) .def("__ge__", &greaterThanEqual) .def("dimensions", &Color3::dimensions,"dimensions() number of dimensions in the color") .staticmethod("dimensions") .def("baseTypeEpsilon", &Color3::baseTypeEpsilon,"baseTypeEpsilon() epsilon value of the base type of the color") .staticmethod("baseTypeEpsilon") .def("baseTypeMax", &Color3::baseTypeMax,"baseTypeMax() max value of the base type of the color") .staticmethod("baseTypeMax") .def("baseTypeLowest", &Color3::baseTypeLowest,"baseTypeLowest() largest negative value of the base type of the color") .staticmethod("baseTypeLowest") .def("baseTypeSmallest", &Color3::baseTypeSmallest,"baseTypeSmallest() smallest value of the base type of the color") .staticmethod("baseTypeSmallest") .def("hsv2rgb", &hsv2rgb, "C.hsv2rgb() -- returns a new color which " "is C converted from RGB to HSV") .def("hsv2rgb", &rgb2hsvTuple) .def("rgb2hsv", &rgb2hsv, "C.rgb2hsv() -- returns a new color which " "is C converted from HSV to RGB") .def("rgb2hsv", &rgb2hsvTuple) .def("setValue", &setValue1, "C1.setValue(C2)\nC1.setValue(a,b,c) -- " "set C1's elements") .def("setValue", &setValue2) .def("setValue", &setValueTuple) ; decoratecopy(color3_class); return color3_class; } template PYIMATH_EXPORT class_, bases > > register_Color3(); template PYIMATH_EXPORT class_, bases > > register_Color3(); template PYIMATH_EXPORT class_ > > register_Color3Array(); template PYIMATH_EXPORT class_ > > register_Color3Array(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color3 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color3(0,0,0); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color3 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color3(0,0,0); } }