Exemplo n.º 1
0
void register_iterator_pair(const std::string& name) {
  using namespace boost::python;
  using self_ns::str;
  class_<std::pair<It,It> >(name.c_str(), no_init)
    .def("__iter__", range(&iterator_pair<It>::begin,
                           &iterator_pair<It>::end))
    .def(str(self));
}
Exemplo n.º 2
0
// Declare the OIIO ROI class to Python
void declare_roi()
{

    class_<ROI>("ROI")
        .def_readwrite("xbegin",   &ROI::xbegin)
        .def_readwrite("xend",     &ROI::xend)
        .def_readwrite("ybegin",   &ROI::ybegin)
        .def_readwrite("yend",     &ROI::yend)
        .def_readwrite("zbegin",   &ROI::zbegin)
        .def_readwrite("zend",     &ROI::zend)
        .def_readwrite("chbegin",  &ROI::chbegin)
        .def_readwrite("chend",    &ROI::chend)

        .def(init<int,int,int,int>())
        .def(init<int,int,int,int,int,int>())
        .def(init<int,int,int,int,int,int,int,int>())
        .def(init<const ROI&>())

        .add_property("defined",   &ROI::defined)
        .add_property("width",     &ROI::width)
        .add_property("height",    &ROI::height)
        .add_property("depth",     &ROI::depth)
        .add_property("nchannels", &ROI::nchannels)
        .add_property("npixels",   &ROI::npixels)

        .def_readonly("All",                &ROI_All)

        // Define Python str(ROI), it automatically uses '<<'
        .def(str(self))    // __str__

        // roi_union, roi_intersection, get_roi(spec), get_roi_full(spec)
        // set_roi(spec,newroi), set_roi_full(newroi)

        // overloaded operators
        .def(self == other<ROI>())    // operator==
        .def(self != other<ROI>())    // operator!=
    ;

    def("union",        &roi_union);
    def("intersection", &roi_intersection);
    def("get_roi",      &get_roi);
    def("get_roi_full", &get_roi_full);
    def("set_roi",      &set_roi);
    def("set_roi_full", &set_roi_full);
}
Exemplo n.º 3
0
// Declare the OIIO TypeDesc type to Python
void declare_typedesc() {

    enum_<TypeDesc::BASETYPE>("BASETYPE")
        .value("UNKNOWN",   TypeDesc::UNKNOWN)
        .value("NONE",      TypeDesc::NONE)
        .value("UCHAR",     TypeDesc::UCHAR)
        .value("UINT8",     TypeDesc::UINT8)
        .value("CHAR",      TypeDesc::CHAR)
        .value("INT8",      TypeDesc::INT8)
        .value("USHORT",    TypeDesc::USHORT)
        .value("UINT16",    TypeDesc::UINT16)
        .value("SHORT",     TypeDesc::SHORT)
        .value("INT16",     TypeDesc::INT16)
        .value("UINT",      TypeDesc::UINT)
        .value("UINT32",    TypeDesc::UINT32)
        .value("INT",       TypeDesc::INT)
        .value("INT32",     TypeDesc::INT32)
        .value("ULONGLONG", TypeDesc::ULONGLONG)
        .value("UINT64",    TypeDesc::UINT64)
        .value("LONGLONG",  TypeDesc::LONGLONG)
        .value("INT64",     TypeDesc::INT64)
        .value("HALF",      TypeDesc::HALF)
        .value("FLOAT",     TypeDesc::FLOAT)
        .value("DOUBLE",    TypeDesc::DOUBLE)
        .value("STRING",    TypeDesc::STRING)
        .value("PTR",       TypeDesc::PTR)
        .value("LASTBASE",  TypeDesc::LASTBASE)
        .export_values()
    ;

    enum_<TypeDesc::AGGREGATE>("AGGREGATE")
        .value("SCALAR",    TypeDesc::SCALAR)
        .value("VEC2",      TypeDesc::VEC2)
        .value("VEC3",      TypeDesc::VEC3)
        .value("VEC4",      TypeDesc::VEC4)
        .value("MATRIX44",  TypeDesc::MATRIX44)
        .export_values()
    ;
    
    enum_<TypeDesc::VECSEMANTICS>("VECSEMANTICS")
        .value("NOXFORM",  TypeDesc::NOXFORM)
        .value("NOSEMANTICS", TypeDesc::NOSEMANTICS)
        .value("COLOR",    TypeDesc::COLOR)
        .value("POINT",    TypeDesc::POINT)
        .value("VECTOR",   TypeDesc::VECTOR)
        .value("NORMAL",   TypeDesc::NORMAL)
        .value("TIMECODE", TypeDesc::TIMECODE)
        .value("KEYCODE",  TypeDesc::KEYCODE)
        .export_values()
    ;

    class_<TypeDesc>("TypeDesc")
        // basetype, aggregate, and vecsemantics should look like BASETYPE,
        // AGGREGATE, VECSEMANTICS, but since they are stored as unsigned
        // char, def_readwrite() doesn't do the right thing. Instead, we
        // use set_foo/get_foo wrappers, but from Python it looks like
        // regular member access.
        .add_property("basetype", &TypeDesc_get_basetype, &TypeDesc_set_basetype)
        .add_property("aggregate", &TypeDesc_get_aggregate, &TypeDesc_set_aggregate)
        .add_property("vecsemantics", &TypeDesc_get_vecsemantics, &TypeDesc_set_vecsemantics)
        .def_readwrite("arraylen",      &TypeDesc::arraylen)
        // Constructors: () [defined implicitly], (base), (base, agg), 
        // (base,agg,vecsem), (base,agg,vecsem,arraylen), string.
        .def(init<TypeDesc::BASETYPE>())
        .def(init<TypeDesc::BASETYPE, TypeDesc::AGGREGATE>())
        .def(init<TypeDesc::BASETYPE, TypeDesc::AGGREGATE, TypeDesc::VECSEMANTICS>())
        .def(init<TypeDesc::BASETYPE, TypeDesc::AGGREGATE, TypeDesc::VECSEMANTICS, int>())
        .def(init<const char *>())
        // Unfortunately, overloading the int varieties, as we do in C++,
        // doesn't seem to work properly, it can't distinguish between an
        // int and an AGGREGATE, for example. Maybe in C++11 with strong
        // enum typing, it will work. But for now, we must forego these
        // variants of the constructors:
        //   .def(init<TypeDesc::BASETYPE, int>())
        //   .def(init<TypeDesc::BASETYPE, TypeDesc::AGGREGATE, int>())
        .def("c_str",            &TypeDesc::c_str)
        .def("numelements",      &TypeDesc::numelements)
        .def("size",             &TypeDesc::size)
        .def("elementtype",      &TypeDesc::elementtype)
        .def("elementsize",      &TypeDesc::elementsize)
        .def("basesize",         &TypeDesc::basesize)
        .def("fromstring",       &TypeDesc_fromstring)
        .def("equivalent",       &TypeDesc::equivalent)
        .def("unarray",          &TypeDesc::unarray)
        .def("is_vec3",          &TypeDesc::is_vec3)
        .def("is_vec4",          &TypeDesc::is_vec4)

        // overloaded operators
        .def(self == other<TypeDesc>())    // operator==
        .def(self != other<TypeDesc>())    // operator!=

        // Define Python str(TypeDesc), it automatically uses '<<'
        .def(str(self))    // __str__

        // Static members of pre-constructed types
        .def_readonly("TypeFloat",    &TypeDesc::TypeFloat)
        .def_readonly("TypeColor",    &TypeDesc::TypeColor)
        .def_readonly("TypeString",   &TypeDesc::TypeString)
        .def_readonly("TypeInt",      &TypeDesc::TypeInt)
        .def_readonly("TypeHalf",     &TypeDesc::TypeHalf)
        .def_readonly("TypePoint",    &TypeDesc::TypePoint)
        .def_readonly("TypeVector",   &TypeDesc::TypeVector)
        .def_readonly("TypeNormal",   &TypeDesc::TypeNormal)
        .def_readonly("TypeMatrix",   &TypeDesc::TypeMatrix)
        .def_readonly("TypeTimeCode", &TypeDesc::TypeTimeCode)
        .def_readonly("TypeKeyCode",  &TypeDesc::TypeKeyCode)
        .def_readonly("TypeFloat4",   &TypeDesc::TypeFloat4)
    ;

}