void bindLookup(const char *bindName)
{
class_< Lookup<T,U>, boost::noncopyable>(bindName, no_init)
.def(init<>())
.def( "init", &initLookup<T,U>, ( arg_( "self" ), arg_( "func" ), arg_( "xMin" ) = 0, arg_( "xMax" )= 1, arg_( "numSamples" )=100 ) )
.def("__call__", &Lookup<T,U>::operator() )
.def("__call__", &vectorLookup<T,U> )
;
}
void bindDeepImageWriter()
{
RunTimeTypedClass<DeepImageWriter>()
.def( "writePixel", &DeepImageWriter::writePixel, ( arg_( "x" ), arg_( "y" ), arg_( "pixel" ) ) )
.def( "create", &DeepImageWriter::create ).staticmethod( "create" )
.def( "supportedExtensions", ( list(*)( ) )&supportedExtensions )
.def( "supportedExtensions", ( list(*)( TypeId ) )&supportedExtensions )
.staticmethod( "supportedExtensions" )
;
}
void bindColorAlgo()
{
object module( borrowed( PyImport_AddModule( "IECoreImage.ColorAlgo" ) ) );
scope().attr( "ColorAlgo" ) = module;
scope moduleScope( module );
def( "transformImage", &ColorAlgo::transformImage, ( arg_( "image" ), arg_( "inputSpace" ), arg_( "outputSpace" ) ) );
def( "transformChannel", &ColorAlgo::transformChannel, ( arg_( "channel" ), arg_( "inputSpace" ), arg_( "outputSpace" ) ) );
}
void bindDeepImageReader()
{
RunTimeTypedClass<DeepImageReader>()
.def( "isComplete", &DeepImageReader::isComplete )
.def( "channelNames", &channelNames )
.def( "dataWindow", &DeepImageReader::dataWindow )
.def( "displayWindow", &DeepImageReader::displayWindow )
.def( "worldToCameraMatrix", &DeepImageReader::worldToCameraMatrix )
.def( "worldToNDCMatrix", &DeepImageReader::worldToNDCMatrix )
.def( "readPixel", &DeepImageReader::readPixel, ( arg_( "x" ), arg_( "y" ) ) )
;
}
void bindMeshPrimitive()
{
RunTimeTypedClass<MeshPrimitive>()
.def( init<>() )
.def( init<IntVectorDataPtr, IntVectorDataPtr, optional<const std::string &, V3fVectorDataPtr> >() )
.def( "numFaces", &MeshPrimitive::numFaces )
/// \todo I'd rather see these bound as functions rather than properties so they match the C++ interface.
/// I think this is particularly important for verticesPerFace and vertexIds as it's pretty unintuitive that a property
/// should return a copy. This is something we need to be more consistent about throughout cortex.
.add_property( "verticesPerFace", &verticesPerFace, "A copy of the mesh's list of vertices per face." )
.add_property( "vertexIds", &vertexIds, "A copy of the mesh's list of vertex ids." )
.add_property( "interpolation", make_function( &MeshPrimitive::interpolation, return_value_policy<copy_const_reference>() ), &MeshPrimitive::setInterpolation )
.def( "setTopology", &MeshPrimitive::setTopology )
.def( "createBox", &MeshPrimitive::createBox, ( arg_( "bounds" ) ) ).staticmethod( "createBox" )
.def( "createPlane", &MeshPrimitive::createPlane, ( arg_( "bounds" ), arg_( "divisions" ) = Imath::V2i( 1 ) ) ).staticmethod( "createPlane" )
.def( "createSphere", &MeshPrimitive::createSphere, ( arg_( "radius" ), arg_( "zMin" ) = -1.0f, arg_( "zMax" ) = 1.0f, arg_( "thetaMax" ) = 360.0f, arg_( "divisions" ) = Imath::V2i( 20, 40 ) ) ).staticmethod( "createSphere" )
;
}
void bindCameraController()
{
class_<CameraController, boost::noncopyable> cls( "CameraController", init<CameraPtr>() );
scope s( cls );
// define enums first, because they are needed for default argument definitions
enum_<CameraController::ScreenWindowAdjustment>( "ScreenWindowAdjustment" )
.value( "CropScreenWindow", CameraController::CropScreenWindow )
.value( "ScaleScreenWindow", CameraController::ScaleScreenWindow )
;
enum_<CameraController::MotionType>( "MotionType" )
.value( "None", CameraController::None )
.value( "Track", CameraController::Track )
.value( "Tumble", CameraController::Tumble )
.value( "Dolly", CameraController::Dolly )
;
cls.def( "setCamera", &CameraController::setCamera )
.def( "getCamera", (CameraPtr (CameraController::*)())&CameraController::getCamera )
.def( "setCentreOfInterest", &CameraController::setCentreOfInterest )
.def( "getCentreOfInterest", &CameraController::getCentreOfInterest )
.def(
"setResolution",
(void (CameraController::*)( const Imath::V2i &, CameraController::ScreenWindowAdjustment ))&CameraController::setResolution,
(
arg_( "resolution" ),
arg_( "adjustment" ) = CameraController::ScaleScreenWindow
)
)
.def( "getResolution", &CameraController::getResolution, return_value_policy<copy_const_reference>() )
.def( "frame", (void (CameraController::*)( const Imath::Box3f & ))&CameraController::frame )
.def( "frame", (void (CameraController::*)( const Imath::Box3f &, const Imath::V3f &, const Imath::V3f & ))&CameraController::frame )
.def( "unproject", &unproject )
.def( "project", &CameraController::project )
.def( "motionStart", &CameraController::motionStart )
.def( "motionUpdate", &CameraController::motionUpdate )
.def( "motionEnd", &CameraController::motionEnd )
;
}
void bindCurvesAlgo()
{
object curveAlgoModule( borrowed( PyImport_AddModule( "IECore.CurvesAlgo" ) ) );
scope().attr( "CurvesAlgo" ) = curveAlgoModule;
scope meshAlgoScope( curveAlgoModule );
def( "resamplePrimitiveVariable", &CurvesAlgo::resamplePrimitiveVariable );
def( "deleteCurves", &CurvesAlgo::deleteCurves, arg_( "invert" ) = false );
def( "segment", ::segment, segmentOverLoads());
def( "updateEndpointMultiplicity", &CurvesAlgo::updateEndpointMultiplicity );
}
explicit
value_type(Arg1&& arg)
{
Arg1 arg_(std::move(arg));
}
void bindMeshAlgo()
{
object meshAlgoModule( borrowed( PyImport_AddModule( "IECore.MeshAlgo" ) ) );
scope().attr( "MeshAlgo" ) = meshAlgoModule;
scope meshAlgoScope( meshAlgoModule );
StdPairToTupleConverter<PrimitiveVariable, PrimitiveVariable>();
def( "calculateTangents", &MeshAlgo::calculateTangents, ( arg_( "mesh" ), arg_( "uvSet" ) = "uv", arg_( "orthoTangents" ) = true, arg_( "position" ) = "P" ) );
def( "calculateFaceArea", &MeshAlgo::calculateFaceArea, ( arg_( "mesh" ), arg_( "position" ) = "P" ) );
def( "calculateFaceTextureArea", &MeshAlgo::calculateFaceTextureArea, ( arg_( "mesh" ), arg_( "uvSet" ) = "uv", arg_( "position" ) = "P" ) );
def( "calculateDistortion", &MeshAlgo::calculateDistortion, ( arg_( "mesh" ), arg_( "uvSet" ) = "uv", arg_( "referencePosition" ) = "Pref", arg_( "position" ) = "P" ) );
def( "resamplePrimitiveVariable", &MeshAlgo::resamplePrimitiveVariable );
def( "deleteFaces", &MeshAlgo::deleteFaces, arg_( "invert" ) = false );
def( "reverseWinding", &MeshAlgo::reverseWinding );
def( "reorderVertices", &MeshAlgo::reorderVertices, ( arg_( "mesh" ), arg_( "id0" ), arg_( "id1" ), arg_( "id2" ) ) );
def( "distributePoints", &MeshAlgo::distributePoints, ( arg_( "mesh" ), arg_( "density" ) = 100.0, arg_( "offset" ) = Imath::V2f( 0 ), arg_( "densityMask" ) = "density", arg_( "uvSet" ) = "uv", arg_( "position" ) = "P" ) );
def( "segment", &::segment, segmentOverLoads() );
}
