soc-2008-mxcurioni: filled and tested StrokeVertex class

source/blender/freestyle/SConscript

@@ -68,7 +68,7 @@ python_sources = [
 					prefix + '/IntegrationType.cpp',
 					prefix + '/Interface0D.cpp',
 					prefix + '/Interface0D/CurvePoint.cpp',
-					# prefix + '/Interface0D/CurvePoint/StrokeVertex.cpp',
+					prefix + '/Interface0D/CurvePoint/StrokeVertex.cpp',
 					prefix + '/Interface0D/SVertex.cpp',
 					prefix + '/Interface0D/ViewVertex.cpp',
 					prefix + '/Interface1D.cpp',

source/blender/freestyle/intern/python/Convert.cpp

@@ -75,6 +75,13 @@ PyObject * BPy_Nature_from_Nature( unsigned short n ) {
 	return py_n;
 }
 
+PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa ) {
+	PyObject *py_sa = StrokeAttribute_Type.tp_new( &StrokeAttribute_Type, 0, 0 );
+	((BPy_StrokeAttribute *) py_sa)->sa = new StrokeAttribute( sa );
+
+	return py_sa;	
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus

source/blender/freestyle/intern/python/Convert.h

@@ -10,6 +10,7 @@ using namespace Geometry;
 #include "Interface0D/SVertex.h"
 #include "Interface1D/FEdge.h"
 #include "Nature.h"
+#include "StrokeAttribute.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -27,11 +28,12 @@ PyObject * Vector_from_Vec2f( Vec2f& v );
 PyObject * Vector_from_Vec3f( Vec3f& v );
 PyObject * Vector_from_Vec3r( Vec3r& v );
 
-PyObject * BPy_Id_from_Id( Id& id );
-PyObject * BPy_SVertex_from_SVertex( SVertex& sv );
 PyObject * BPy_FEdge_from_FEdge( FEdge& fe );
+PyObject * BPy_Id_from_Id( Id& id );
 PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
 PyObject * BPy_Nature_from_Nature( unsigned short n );
+PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa );
+PyObject * BPy_SVertex_from_SVertex( SVertex& sv );
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 

source/blender/freestyle/intern/python/Interface0D.cpp

@@ -2,6 +2,7 @@
 
 #include "Convert.h"
 #include "Interface0D/CurvePoint.h"
+#include "Interface0D/CurvePoint/StrokeVertex.h"
 #include "Interface0D/SVertex.h"
 #include "Interface0D/ViewVertex.h"
 #include "Interface1D/FEdge.h"
@@ -159,6 +160,10 @@ PyMODINIT_FUNC Interface0D_Init( PyObject *module )
 	Py_INCREF( &ViewVertex_Type );
 	PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type);
 	
+	if( PyType_Ready( &StrokeVertex_Type ) < 0 )
+		return;
+	Py_INCREF( &StrokeVertex_Type );
+	PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type);
 }
 
 //------------------------INSTANCE METHODS ----------------------------------

source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.cpp

@@ -1,6 +1,7 @@
 #include "StrokeVertex.h"
 
 #include "../../Convert.h"
+#include "../../StrokeAttribute.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -11,10 +12,36 @@ extern "C" {
 /*---------------  Python API function prototypes for StrokeVertex instance  -----------*/
 static int StrokeVertex___init__(BPy_StrokeVertex *self, PyObject *args, PyObject *kwds);
 
+static PyObject * StrokeVertex_x( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_y( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_strokeLength( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_u( BPy_StrokeVertex *self );
+static PyObject * StrokeVertex_setX( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setY( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setPoint( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setAttribute( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setCurvilinearAbscissa( BPy_StrokeVertex *self , PyObject *args);
+static PyObject * StrokeVertex_setStrokeLength( BPy_StrokeVertex *self , PyObject *args);
 
 /*----------------------StrokeVertex instance definitions ----------------------------*/
 static PyMethodDef BPy_StrokeVertex_methods[] = {	
 //	{"__copy__", ( PyCFunction ) StrokeVertex___copy__, METH_NOARGS, "（ ）Cloning method."},
+	{"x", ( PyCFunction ) StrokeVertex_x, METH_NOARGS, "（ ）Returns the 2D point x coordinate"},
+	{"y", ( PyCFunction ) StrokeVertex_y, METH_NOARGS, "（ ）Returns the 2D point y coordinate"},
+	{"getPoint", ( PyCFunction ) StrokeVertex_getPoint, METH_NOARGS, "（ ）Returns the 2D point coordinates as a Vec2d"},
+	{"attribute", ( PyCFunction ) StrokeVertex_attribute, METH_NOARGS, "（ ）Returns the StrokeAttribute of this StrokeVertex"},
+	{"curvilinearAbscissa", ( PyCFunction ) StrokeVertex_curvilinearAbscissa, METH_NOARGS, "（ ）Returns the curvilinear abscissa "},
+	{"strokeLength", ( PyCFunction ) StrokeVertex_strokeLength, METH_NOARGS, "（ ）Returns the length of the Stroke to which this StrokeVertex belongs"},
+	{"u", ( PyCFunction ) StrokeVertex_u, METH_NOARGS, "（ ）Returns the curvilinear abscissa of this StrokeVertex in the Stroke"},
+	{"setX", ( PyCFunction ) StrokeVertex_setX, METH_VARARGS, "（double r ）Sets the 2D x value "},
+	{"setY", ( PyCFunction ) StrokeVertex_setY, METH_VARARGS, "（double r ）Sets the 2D y value "},
+	{"setPoint", ( PyCFunction ) StrokeVertex_setPoint, METH_VARARGS, "(double x, double y) / ( [x,y] ) Sets the 2D x and y values"},
+	{"setAttribute", ( PyCFunction ) StrokeVertex_setAttribute, METH_VARARGS, "（StrokeAttribute sa ）Sets the attribute."},
+	{"setCurvilinearAbscissa", ( PyCFunction ) StrokeVertex_setCurvilinearAbscissa, METH_VARARGS, "（double r ）Sets the curvilinear abscissa of this StrokeVertex in the Stroke"},
+	{"setStrokeLength", ( PyCFunction ) StrokeVertex_setStrokeLength, METH_VARARGS, "（double r ）Sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the real Stroke's length.) "},
 	{NULL, NULL, 0, NULL}
 };
 
@@ -79,7 +106,7 @@ PyTypeObject StrokeVertex_Type = {
 	BPy_StrokeVertex_methods,	/* struct PyMethodDef *tp_methods; */
 	NULL,                       	/* struct PyMemberDef *tp_members; */
 	NULL,         					/* struct PyGetSetDef *tp_getset; */
-	&Interface0D_Type,				/* struct _typeobject *tp_base; */
+	&CurvePoint_Type,				/* struct _typeobject *tp_base; */
 	NULL,							/* PyObject *tp_dict; */
 	NULL,							/* descrgetfunc tp_descr_get; */
 	NULL,							/* descrsetfunc tp_descr_set; */
@@ -117,138 +144,152 @@ int StrokeVertex___init__(BPy_StrokeVertex *self, PyObject *args, PyObject *kwds
         return -1;
 
 	if( !obj1 && !obj2 && !obj3 ){
-		self->cp = new CurvePoint();
+		self->sv = new StrokeVertex();
-	} else if( PyFloat_Check(obj3) ) {
+		
-		if( BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) {
+	} else if( BPy_CurvePoint_Check(obj1) && ((BPy_CurvePoint *) obj1)->cp ) {
-			self->cp = new CurvePoint(  ((BPy_SVertex *) obj1)->sv,
+		self->sv = new StrokeVertex( ((BPy_CurvePoint *) obj1)->cp );
-										((BPy_SVertex *) obj2)->sv,
+	
+	} else if( BPy_SVertex_Check(obj1) && ((BPy_SVertex *) obj1)->sv ) {
+		self->sv = new StrokeVertex( ((BPy_SVertex *) obj1)->sv );
+	
+	} else if( BPy_StrokeVertex_Check(obj1) && BPy_StrokeVertex_Check(obj2) 
+				&& ((BPy_StrokeVertex *) obj1)->sv && ((BPy_StrokeVertex *) obj2)->sv) {
+	
+		self->sv = new StrokeVertex(	((BPy_StrokeVertex *) obj1)->sv,
+										((BPy_StrokeVertex *) obj2)->sv,
 										PyFloat_AsDouble( obj3 ) );
-		} else if( BPy_CurvePoint_Check(obj1) && BPy_CurvePoint_Check(obj2) ) {
-			self->cp = new CurvePoint(  ((BPy_CurvePoint *) obj1)->cp,
-										((BPy_CurvePoint *) obj2)->cp,
-										PyFloat_AsDouble( obj3 ) );
-		} else {
-			return -1;	
-		}		
 	} else {
 		return -1;
 	}
 
-	self->py_if0D.if0D = self->cp;
+	self->py_cp.cp = self->sv;
+	self->py_cp.py_if0D.if0D = self->sv;
 
 	return 0;
 }
 
+PyObject * StrokeVertex_x( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->x() );
+}
 
+PyObject * StrokeVertex_y( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->y() );
+}
+
+PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self ) {
+	Vec2f v( self->sv->getPoint() );
+	return Vector_from_Vec2f( v );
+}
+
+PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self ) {
+	StrokeAttribute sa( self->sv->attribute() );
+	return BPy_StrokeAttribute_from_StrokeAttribute( sa );
+}
+
+PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->curvilinearAbscissa() );
+}
+
+PyObject * StrokeVertex_strokeLength( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->strokeLength() );
+}
+
+PyObject * StrokeVertex_u( BPy_StrokeVertex *self ) {
+	return PyFloat_FromDouble( self->sv->u() );
+}
+
+
+PyObject *StrokeVertex_setX( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setX" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setX( r );
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setY( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setY" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setY( r );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *StrokeVertex_setPoint( BPy_StrokeVertex *self , PyObject *args) {
+	PyObject *obj1 = 0, *obj2 = 0;
+
+	if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) )) {
+		cout << "ERROR: StrokeVertex_setPoint" << endl;
+		Py_RETURN_NONE;
+	}
+	
+	if( PyList_Check(obj1) && !obj2 ){
+		Vec2f v( 	PyFloat_AsDouble( PyList_GetItem(obj1, 0) ),
+					PyFloat_AsDouble( PyList_GetItem(obj1, 1) )  );
+		self->sv->setPoint( v );
+	} else if( obj1 && obj2 ){
+		self->sv->setPoint( PyFloat_AsDouble(obj1), PyFloat_AsDouble(obj2) );
+	}
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setAttribute( BPy_StrokeVertex *self , PyObject *args) {
+	PyObject *py_sa;
+
+	if(!( PyArg_ParseTuple(args, "O", &py_sa) && BPy_StrokeAttribute_Check(py_sa)  )) {
+		cout << "ERROR: StrokeVertex_setAttribute" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setAttribute(*( ((BPy_StrokeAttribute *) py_sa)->sa ));
+
+	Py_RETURN_NONE;
+}
+
+PyObject *StrokeVertex_setCurvilinearAbscissa( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setCurvilinearAbscissa" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setCurvilinearAbscissa( r );
+
+	Py_RETURN_NONE;
+}
+
+
+PyObject *StrokeVertex_setStrokeLength( BPy_StrokeVertex *self , PyObject *args) {
+	double r;
+
+	if(!( PyArg_ParseTuple(args, "d", &r)  )) {
+		cout << "ERROR: StrokeVertex_setStrokeLength" << endl;
+		Py_RETURN_NONE;
+	}
+
+	self->sv->setStrokeLength( r );
+
+	Py_RETURN_NONE;
+}
+
+// real 	operator[] (const int i) const
+// real & 	operator[] (const int i)
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus
 }
 #endif
-
-
-//  PyObject *_wrap_StrokeVertex_getExactTypeName(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_0(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_1(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_2(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_3(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_4(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex__SWIG_5(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_new_StrokeVertex(PyObject *self, PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_delete_StrokeVertex(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_x(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_y(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_getPoint(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_attribute__SWIG_0(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_attribute__SWIG_1(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_attribute(PyObject *self, PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_curvilinearAbscissa(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_strokeLength(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_u(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetX(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetY(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetPoint__SWIG_0(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetPoint__SWIG_1(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetPoint(PyObject *self, PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetAttribute(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetCurvilinearAbscissa(PyObject *self , PyObject *args) {
-// }
-// 
-// 
-//  PyObject *_wrap_StrokeVertex_SetStrokeLength(PyObject *self , PyObject *args) {
-// }
-// 
-

source/blender/freestyle/intern/python/Interface0D/CurvePoint/StrokeVertex.h

@@ -2,7 +2,7 @@
 #define FREESTYLE_PYTHON_STROKEVERTEX_H
 
 #include "../CurvePoint.h"
-#include "../../stroke/Stroke.h"
+#include "../../../stroke/Stroke.h"
 
 #ifdef __cplusplus
 extern "C" {