// Copyright (c) 2000, 2001, 2002, 2003 by David Scherer and others.

// Copyright (c) 2003, 2004 Jonathan Brandmeyer and others.

// See the file license.txt for complete license terms.

// See the file authors.txt for a complete list of contributors.

// This file currently requires 144 MB to compile (optimizing).

#include "python/curve.hpp"

#include "python/extrusion.hpp"

#include "python/faces.hpp"

#include "python/convex.hpp"

#include "python/points.hpp"

#include "python/num_util.hpp"

#include <boost/python/class.hpp>

#include <boost/python/args.hpp>

#include <boost/python/overloads.hpp>

#include <boost/python/detail/wrap_python.hpp>

// Python 2/3 compatibility

#ifndef PyString_Check

#define PyString_Check PyUnicode_Check

#endif

namespace cvisual {

using python::double_array;

struct double_array_from_python {

double_array_from_python() {

boost::python::converter::registry::push_back(

&convertible,

&construct,

boost::python::type_id< double_array >());

}

static void* convertible(PyObject* obj_ptr)

{

using namespace boost::python;

// TODO: We are supposed to determine if construct will succeed. But

// this is difficult and expensive for arbitrary sequences. So we

// assume that anything that looks like a sequence will convert and

// throw an exception later. This limits overload resolution, but

// most of our functions taking arrays have no overloads.

// Legend has it that numpy arrays don't satisfy PySequence_Check so

/// we check if len(x) succeeds.

if ( PySequence_Size(obj_ptr) < 0 ) {

PyErr_Clear();

return NULL;

}

// Strings have length but definitely don't convert to double_array!

if ( PyString_Check(obj_ptr) || PyUnicode_Check(obj_ptr) )

return NULL;

return obj_ptr;

}

static void construct(

PyObject* _obj,

boost::python::converter::rvalue_from_python_stage1_data* data)

{

using namespace boost::python;

void* storage = (

(boost::python::converter::rvalue_from_python_storage<double_array>*)

data)->storage.bytes;

Py_INCREF(_obj);

PyObject* arr = PyArray_FromAny(_obj, PyArray_DescrFromType(NPY_DOUBLE), 0, 0, NPY_ENSUREARRAY|NPY_CONTIGUOUS|NPY_ALIGNED, NULL);

if (!arr)

throw std::invalid_argument("Object cannot be converted to array.");

new (storage) double_array( handle<>(arr) );

data->convertible = storage;

}

};

void

wrap_arrayobjects()

{

using namespace boost::python;

double_array_from_python();

{

using python::curve;

// TODO: the arrayprim inheritance hierarchy could be exposed here; for now I've left the duplication here

// to make it easy to control exactly what goes in the API for each array primitive, but arguably they

// should be as similar as possible!

void (curve::*append_v_rgb_retain)( const vector&, const rgb&, int ) = &curve::append;

void (curve::*append_v_retain)( const vector&, int ) = &curve::append;

class_<curve, bases<renderable> >( "curve")

.def( init<const curve&>())

.add_property( "radius", &curve::get_radius, &curve::set_radius) // AKA thickness.

.def( "get_color", &curve::get_color)

.def( "set_color", &curve::set_color)

.def( "set_red", &curve::set_red_d)

.def( "set_red", &curve::set_red)

.def( "set_green", &curve::set_green_d)

.def( "set_green", &curve::set_green)

.def( "set_blue", &curve::set_blue_d)

.def( "set_blue", &curve::set_blue)

.def( "get_pos", &curve::get_pos)

.def( "set_pos", &curve::set_pos)

.def( "set_pos", &curve::set_pos_v)

.def( "set_x", &curve::set_x_d)

.def( "set_x", &curve::set_x)

.def( "set_y", &curve::set_y_d)

.def( "set_y", &curve::set_y)

.def( "set_z", &curve::set_z_d)

.def( "set_z", &curve::set_z)

.def( "append", append_v_rgb_retain, ( arg("pos"), arg("color"), arg("retain")=-1 ) )

.def( "append", append_v_retain, ( arg("pos"), arg("retain")=-1 ) )

.def( "append", &curve::append_rgb,

( arg("pos"), arg("red")=-1, arg("green")=-1, arg("blue")=-1, arg("retain")=-1 ) )

;

}

{

using python::extrusion;

class_<extrusion, bases<renderable> >( "extrusion")

.def( init<const extrusion&>())

.def( "get_color", &extrusion::get_color)

.def( "set_color", &extrusion::set_color)

.def( "set_red", &extrusion::set_red_d)

.def( "set_red", &extrusion::set_red)

.def( "set_green", &extrusion::set_green_d)

.def( "set_green", &extrusion::set_green)

.def( "set_blue", &extrusion::set_blue_d)

.def( "set_blue", &extrusion::set_blue)

.def( "get_pos", &extrusion::get_pos)

.def( "set_pos", &extrusion::set_pos)

.def( "set_pos", &extrusion::set_pos_v)

.def( "set_x", &extrusion::set_x_d)

.def( "set_x", &extrusion::set_x)

.def( "set_y", &extrusion::set_y_d)

.def( "set_y", &extrusion::set_y)

.def( "set_z", &extrusion::set_z_d)

.def( "set_z", &extrusion::set_z)

// There were unsolvable problems with rotate. See comments with intrude routine.

//.def( "rotate", &extrusion::rotate, (arg("angle"), arg("axis"), arg("origin")))

.add_property( "up",

make_function(&extrusion::get_up, return_internal_reference<>()),

&extrusion::set_up)

.add_property( "first_normal", &extrusion::get_first_normal, &extrusion::set_first_normal)

.add_property( "last_normal", &extrusion::get_last_normal, &extrusion::set_last_normal)

.add_property( "show_start_face", &extrusion::get_show_start_face, &extrusion::set_show_start_face)

.add_property( "show_end_face", &extrusion::get_show_end_face, &extrusion::set_show_end_face)

.add_property( "start", &extrusion::get_start, &extrusion::set_start)

.add_property( "end", &extrusion::get_end, &extrusion::set_end)

.add_property( "smooth", &extrusion::get_smooth, &extrusion::set_smooth)

.add_property( "twosided", &extrusion::get_twosided, &extrusion::set_twosided)

.add_property( "initial_twist", &extrusion::get_initial_twist, &extrusion::set_initial_twist)

.def( "get_twist", &extrusion::get_twist)

.def( "set_twist", &extrusion::set_twist)

.def( "set_twist", &extrusion::set_twist_d)

.def( "get_scale", &extrusion::get_scale)

.def( "set_scale", &extrusion::set_scale)

.def( "set_scale", &extrusion::set_scale_d)

.def( "set_xscale", &extrusion::set_xscale)

.def( "set_yscale", &extrusion::set_yscale)

.def( "set_xscale", &extrusion::set_xscale_d)

.def( "set_yscale", &extrusion::set_yscale_d)

.def( "set_contours", &extrusion::set_contours) // used by primitives.py to transfer 2D cross section info

.def( "_faces_render", &extrusion::_faces_render) // obtain pos, normal, and color arrays for the extrusion

.def( "append", &extrusion::appendpos_retain, (arg("pos"), arg("retain")=-1))

.def( "append", &extrusion::appendpos_color_retain, (arg("pos"), arg("color"), arg("retain")=-1))

.def( "append", &extrusion::appendpos_rgb_retain,

( arg("pos"), arg("red")=-1, arg("green")=-1, arg("blue")=-1, arg("retain")=-1 ) )

;

}

{

using python::points;

void (points::*pappend_v_r)( const vector&, const rgb&, int ) = &points::append;

void (points::*pappend_v)( const vector&, int ) = &points::append;

class_<points, bases<renderable> >( "points")

.def( init<const points&>())

.add_property( "size", &points::get_size, &points::set_size)

.add_property( "shape", &points::get_points_shape, &points::set_points_shape)

.add_property( "size_units", &points::get_size_units, &points::set_size_units)

.def( "get_color", &points::get_color)

// The order of set_color specifications matters.

//.def( "set_color", &points::set_color_t)

.def( "set_color", &points::set_color)

.def( "set_red", &points::set_red_d)

.def( "set_red", &points::set_red)

.def( "set_green", &points::set_green_d)

.def( "set_green", &points::set_green)

.def( "set_blue", &points::set_blue_d)

.def( "set_blue", &points::set_blue)

.def( "get_pos", &points::get_pos)

.def( "set_pos", &points::set_pos)

.def( "set_pos", &points::set_pos_v)

.def( "set_x", &points::set_x_d)

.def( "set_x", &points::set_x)

.def( "set_y", &points::set_y_d)

.def( "set_y", &points::set_y)

.def( "set_z", &points::set_z_d)

.def( "set_z", &points::set_z)

.def( "append", pappend_v_r, (arg("pos"), arg("color"), arg("retain")=-1))

.def( "append", pappend_v, (arg("pos"), arg("retain")=-1))

.def( "append", &points::append_rgb,

(arg("pos"), arg("red")=-1, arg("green")=-1, arg("blue")=-1, arg("retain")=-1))

;

}

{

using python::faces;

void (faces::* append_all_vectors)(const vector&, const vector&, const rgb&) = &faces::append;

void (faces::* append_default_color)(const vector&, const vector&) = &faces::append;

void (faces::* append_pos)(const vector&) = &faces::append;

class_<faces, bases<renderable> >("faces")

.def( init<const faces&>())

.def( "get_pos", &faces::get_pos)

.def( "set_pos", &faces::set_pos)

.def( "get_normal", &faces::get_normal)

.def( "set_normal", &faces::set_normal_v)

.def( "set_normal", &faces::set_normal)

.def( "get_color", &faces::get_color)

.def( "set_color", &faces::set_color)

//.def( "set_color", &faces::set_color_t)

.def( "set_red", &faces::set_red_d)

.def( "set_red", &faces::set_red)

.def( "set_green", &faces::set_green_d)

.def( "set_green", &faces::set_green)

.def( "set_blue", &faces::set_blue_d)

.def( "set_blue", &faces::set_blue)

.def( "smooth", &faces::smooth,

"Average normal vectors at coincident vertexes.")

.def( "smooth", &faces::smooth_d,

"Average normal vectors at coincident vertexes.")

.def( "make_normals", &faces::make_normals,

"Construct normal vectors perpendicular to all faces.")

.def( "make_twosided", &faces::make_twosided,

"Add a second side and corresponding normals to all faces.")

.def( "append", &faces::append_rgb,

(arg("pos"), arg("normal"), arg("red")=-1, arg("green")=-1, arg("blue")=-1))

.def( "append", append_pos, ( arg("pos") ))

.def( "append", append_default_color, ( arg("pos"), arg("normal") ))

.def( "append", append_all_vectors, (arg("pos"), arg("normal"), arg("color")))

;

}

{

using python::convex;

void (convex::* append_convex)(const vector&) = &convex::append;

class_<convex, bases<renderable> >( "convex")

.def( init<const convex&>())

.def( "append", append_convex, (arg("pos")),

"Append a point to the surface in O(n) time.")

.add_property( "color", &convex::get_color, &convex::set_color)

.def( "set_pos", &convex::set_pos)

.def( "get_pos", &convex::get_pos)

;

}

}

} // !namespace cvisual