// // SPDX-License-Identifier: BSD-3-Clause // Copyright Contributors to the OpenEXR Project. // // clang-format off #include #define BOOST_BIND_GLOBAL_PLACEHOLDERS #include #include #include #include #include #include "PyImath.h" #include "PyImathMathExc.h" #include "PyImathColor.h" #include "PyImathDecorators.h" #include "PyImathExport.h" #include "PyImathColor4Array2DImpl.h" #include "PyImathColor4ArrayImpl.h" namespace PyImath { template <> const char *PyImath::C4cArray::name() { return "C4cArray"; } template <> const char *PyImath::C4fArray::name() { return "C4fArray"; } using namespace boost::python; using namespace IMATH_NAMESPACE; template struct Color4Name { static const char *value; }; template<> const char *Color4Name::value = "Color4c"; template<> const char *Color4Name::value = "Color4f"; // template<> const char *Color4ArrayName::value() { return "Color4fArray"; } // template<> const char *Color4ArrayName::value() { return "Color4cArray"; } template<> const char *Color4Array2DName::value() { return "Color4fArray2D"; } template<> const char *Color4Array2DName::value() { return "Color4cArray2D"; } // create a new default constructor that initializes Color4 to zero. template static Color4 * Color4_construct_default() { return new Color4(T(0),T(0),T(0),T(0)); } template static Color4 * Color4_component_construct1(S x, S y, S z, S w) { // 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(Color4Name::value, "Color4c") == 0) { unsigned char r = (unsigned char) x; unsigned char g = (unsigned char) y; unsigned char b = (unsigned char) z; unsigned char a = (unsigned char) w; return new Color4(r,g,b,a); } else return new Color4(T(x) , T(y), T(z), T(w)); } template static Color4 * Color4_component_construct2(S x) { MATH_EXC_ON; if(strcmp(Color4Name::value, "Color4c") == 0) { unsigned char u = (unsigned char) x; return new Color4(u,u,u,u); } else return new Color4(T(x),T(x),T(x),T(x)); } template static Color4 * Color4_color_construct(const Color4 &c) { MATH_EXC_ON; if(strcmp(Color4Name::value, "Color4c") == 0) { unsigned char r = (unsigned char) c.r; unsigned char g = (unsigned char) c.g; unsigned char b = (unsigned char) c.b; unsigned char a = (unsigned char) c.a; return new Color4(r,g,b,a); } else return new Color4(T (c.r), T(c.g), T(c.b), T(c.a)); } template static Color4 * Color4_construct_tuple(const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) { return new Color4(extract(t[0]), extract(t[1]), extract(t[2]), extract(t[3])); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 * Color4_construct_list(const list &l) { MATH_EXC_ON; if(l.attr("__len__")() == 4) { return new Color4(extract(l[0]), extract(l[1]), extract(l[2]), extract(l[3])); } else throw std::invalid_argument ("Color4 expects list of length 4"); } template static std::string color4_str(const Color4 &c) { std::stringstream stream; if(strcmp(Color4Name::value, "Color4c") == 0) { int r = int(c.r); int g = int(c.g); int b = int(c.b); int a = int(c.a); stream << Color4Name::value << "(" << r << ", " << g << ", " << b << ", " << a << ")"; return stream.str(); } else { stream << Color4Name::value << "(" << c.r << ", " << c.g << ", " << c.b << ", " << c.a << ")"; return stream.str(); } } // Non-specialized repr is same as str template static std::string color4_repr(const Color4 &c) { return color4_str(c); } // Specialization for float to full precision template <> std::string color4_repr(const Color4 &c) { return (boost::format("%s(%.9g, %.9g, %.9g, %.9g)") % Color4Name::value % c.r % c.g % c.b % c.a).str(); } // No specialization for double, since we don't instantiate Color4d template static Color4 hsv2rgb(Color4 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::hsv2rgb(color); } template static Color4 hsv2rgbTuple(const tuple &t) { MATH_EXC_ON; Color4 color; if(t.attr("__len__")() == 4) { color.r = extract(t[0]); color.g = extract(t[1]); color.b = extract(t[2]); color.a = extract(t[3]); return IMATH_NAMESPACE::hsv2rgb(color); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 rgb2hsv(Color4 &color) { MATH_EXC_ON; return IMATH_NAMESPACE::rgb2hsv(color); } template static Color4 rgb2hsvTuple(const tuple &t) { MATH_EXC_ON; Color4 color; if(t.attr("__len__")() == 4) { color.r = extract(t[0]); color.g = extract(t[1]); color.b = extract(t[2]); color.a = extract(t[3]); return IMATH_NAMESPACE::rgb2hsv(color); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static void setValue1(Color4 &color, const T &a, const T &b, const T &c, const T &d) { MATH_EXC_ON; color.setValue(a, b, c, d); } template static void setValue2(Color4 &color, const Color4 &v) { MATH_EXC_ON; color.setValue(v); } template static void setValueTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; Color4 v; if(t.attr("__len__")() == 4) { v.r = extract(t[0]); v.g = extract(t[1]); v.b = extract(t[2]); v.a = extract(t[3]); color.setValue(v); } else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static const Color4 & iadd(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color += color2; } template static Color4 add(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color + color2; } template static Color4 addTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r + extract(t[0]), color.g + extract(t[1]), color.b + extract(t[2]), color.a + extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 addT(Color4 &v, T a) { MATH_EXC_ON; Color4 w(v.r + a, v.g + a, v.b + a, v.a + a); return w; } template static const Color4 & isub(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color -= color2; } template static Color4 sub(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color - color2; } template static Color4 subtractL(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r - extract(t[0]), color.g - extract(t[1]), color.b - extract(t[2]), color.a - extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 subtractR(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(extract(t[0]) - color.r, extract(t[1]) - color.g, extract(t[2]) - color.b, extract(t[3]) - color.a); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 subtractLT(const Color4 &color, T a) { MATH_EXC_ON; return Color4(color.r - a, color.g - a, color.b - a, color.a - a); } template static Color4 subtractRT(const Color4 &color, T a) { MATH_EXC_ON; return Color4(a - color.r, a - color.g, a - color.b, a - color.a); } template static Color4 neg(Color4 &color) { MATH_EXC_ON; return -color; } template static const Color4 & negate(Color4 &color) { MATH_EXC_ON; return color.negate(); } template static const Color4 & imul(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color *= color2; } template static const Color4 & imulT(Color4 &color, const T &t) { MATH_EXC_ON; return color *= t; } template static Color4 mul(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color * color2; } template static Color4 mulT(Color4 &color, const T &t) { MATH_EXC_ON; return color * t; } template static Color4 rmulT(Color4 &color, const T &t) { MATH_EXC_ON; return t * color; } template static Color4 mulTuple(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r * extract(t[0]), color.g * extract(t[1]), color.b * extract(t[2]), color.a * extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static const Color4 & idiv(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color /= color2; } template static const Color4 & idivT(Color4 &color, const T &t) { MATH_EXC_ON; return color /= t; } template static Color4 div(Color4 &color, const Color4 &color2) { MATH_EXC_ON; return color / color2; } template static Color4 divT(Color4 &color, const T &t) { MATH_EXC_ON; return color / t; } template static Color4 divTupleL(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(color.r / extract(t[0]), color.g / extract(t[1]), color.b / extract(t[2]), color.a / extract(t[3])); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 divTupleR(Color4 &color, const tuple &t) { MATH_EXC_ON; if(t.attr("__len__")() == 4) return Color4(extract(t[0]) / color.r, extract(t[1]) / color.g, extract(t[2]) / color.b, extract(t[3]) / color.a); else throw std::invalid_argument ("Color4 expects tuple of length 4"); } template static Color4 divTR(Color4 &color, T a) { MATH_EXC_ON; return Color4(a / color.r, a / color.g, a / color.b, a / color.a); } template static bool lessThan(Color4 &v, const Color4 &w) { bool isLessThan = (v.r <= w.r && v.g <= w.g && v.b <= w.b && v.a <= w.a) && v != w; return isLessThan; } template static bool greaterThan(Color4 &v, const Color4 &w) { bool isGreaterThan = (v.r >= w.r && v.g >= w.g && v.b >= w.b && v.a >= w.a) && v != w; return isGreaterThan; } template static bool lessThanEqual(Color4 &v, const Color4 &w) { bool isLessThanEqual = (v.r <= w.r && v.g <= w.g && v.b <= w.b && v.a <= w.a); return isLessThanEqual; } template static bool greaterThanEqual(Color4 &v, const Color4 &w) { bool isGreaterThanEqual = (v.r >= w.r && v.g >= w.g && v.b >= w.b) && v.a >= w.a; return isGreaterThanEqual; } template class_ > register_Color4() { typedef PyImath::StaticFixedArray,T,4> Color4_helper; void (IMATH_NAMESPACE::Color4::*getValue1)(Color4 &) const = &IMATH_NAMESPACE::Color4::getValue; void (IMATH_NAMESPACE::Color4::*getValue2)(T &, T &, T &, T &) const = &IMATH_NAMESPACE::Color4::getValue; class_ > color4_class(Color4Name::value, Color4Name::value,init >("copy construction")); color4_class .def("__init__",make_constructor(Color4_construct_default),"initialize to (0,0,0,0)") .def("__init__",make_constructor(Color4_construct_tuple), "initialize to (r,g,b,a) with a python tuple") .def("__init__",make_constructor(Color4_construct_list), "initialize to (r,g,b,a) with a python list") .def("__init__",make_constructor(Color4_component_construct1)) .def("__init__",make_constructor(Color4_component_construct1)) .def("__init__",make_constructor(Color4_component_construct2)) .def("__init__",make_constructor(Color4_component_construct2)) .def("__init__",make_constructor(Color4_color_construct)) .def("__init__",make_constructor(Color4_color_construct)) .def("__init__",make_constructor(Color4_color_construct)) .def_readwrite("r", &Color4::r) .def_readwrite("g", &Color4::g) .def_readwrite("b", &Color4::b) .def_readwrite("a", &Color4::a) .def("__str__", &color4_str) .def("__repr__", &color4_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__", &mulT) .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("__len__", Color4_helper::len) .def("__getitem__", Color4_helper::getitem,return_value_policy()) .def("__setitem__", Color4_helper::setitem) .def("dimensions", &Color4::dimensions,"dimensions() number of dimensions in the color") .staticmethod("dimensions") .def("baseTypeEpsilon", &Color4::baseTypeEpsilon,"baseTypeEpsilon() epsilon value of the base type of the color") .staticmethod("baseTypeEpsilon") .def("baseTypeMax", &Color4::baseTypeMax,"baseTypeMax() max value of the base type of the color") .staticmethod("baseTypeMax") .def("baseTypeLowest", &Color4::baseTypeLowest,"baseTypeLowest() largest negative value of the base type of the color") .staticmethod("baseTypeLowest") .def("baseTypeSmallest", &Color4::baseTypeSmallest,"baseTypeSmallest() smallest value of the base type of the color") .staticmethod("baseTypeSmallest") .def("__repr__",&color4_repr) .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) .def("getValue", getValue1, "getValue()") .def("getValue", getValue2) ; decoratecopy(color4_class); return color4_class; } template PYIMATH_EXPORT class_ > register_Color4(); template PYIMATH_EXPORT class_ > register_Color4(); template PYIMATH_EXPORT class_ > > register_Color4Array(); template PYIMATH_EXPORT class_ > > register_Color4Array(); template PYIMATH_EXPORT class_ > > register_Color4Array2D(); template PYIMATH_EXPORT class_ > > register_Color4Array2D(); template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color4 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color4(0,0,0, 0); } template<> PYIMATH_EXPORT IMATH_NAMESPACE::Color4 PyImath::FixedArrayDefaultValue >::value() { return IMATH_NAMESPACE::Color4(0,0,0,0); } }