griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

soc-2008-mxcurioni: fully implemented (but did not test) ViewEdge class. Modified functions accross API taking input boolean values.

Browse Source
This commit is contained in:
Maxime Curioni
2008-07-25 01:38:19 +00:00
parent d8d9839ab3
commit c0f567e757
5 changed files with 290 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
View File

@@ -1,6 +1,12 @@
#include "BPy_ViewEdge.h"
#include "../BPy_Convert.h"
#include "../BPy_Id.h"
#include "../Interface0D/BPy_ViewVertex.h"
#include "../Interface1D/BPy_FEdge.h"
#include "../Interface1D/BPy_ViewEdge.h"
#include "../BPy_Nature.h"
#include "../BPy_ViewShape.h"
#ifdef __cplusplus
extern "C" {
@@ -13,13 +19,54 @@ static int ViewEdge___init__(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
static PyObject * ViewEdge_A( BPy_ViewEdge *self );
static PyObject * ViewEdge_B( BPy_ViewEdge *self );
static PyObject * ViewEdge_fedgeA( BPy_ViewEdge *self ) ;
static PyObject * ViewEdge_fedgeB( BPy_ViewEdge *self ) ;
static PyObject * ViewEdge_viewShape( BPy_ViewEdge *self ) ;
static PyObject * ViewEdge_aShape( BPy_ViewEdge *self ) ;
static PyObject * ViewEdge_isClosed( BPy_ViewEdge *self );
static PyObject * ViewEdge_getChainingTimeStamp( BPy_ViewEdge *self );
static PyObject * ViewEdge_setChainingTimeStamp( BPy_ViewEdge *self, PyObject *args) ;
static PyObject * ViewEdge_setA( BPy_ViewEdge *self , PyObject *args) ;
static PyObject * ViewEdge_setB( BPy_ViewEdge *self , PyObject *args);
static PyObject * ViewEdge_setNature( BPy_ViewEdge *self, PyObject *args );
static PyObject * ViewEdge_setFEdgeA( BPy_ViewEdge *self, PyObject *args ) ;
static PyObject * ViewEdge_setFEdgeB( BPy_ViewEdge *self, PyObject *args ) ;
static PyObject * ViewEdge_setShape( BPy_ViewEdge *self, PyObject *args ) ;
static PyObject * ViewEdge_setId( BPy_ViewEdge *self, PyObject *args ) ;
static PyObject * ViewEdge_UpdateFEdges( BPy_ViewEdge *self );
static PyObject * ViewEdge_setaShape( BPy_ViewEdge *self, PyObject *args );
static PyObject * ViewEdge_setQI( BPy_ViewEdge *self, PyObject *args );
static PyObject * ViewEdge_verticesBegin( BPy_ViewEdge *self );
static PyObject * ViewEdge_verticesEnd( BPy_ViewEdge *self );
static PyObject * ViewEdge_pointsBegin( BPy_ViewEdge *self, PyObject *args );
static PyObject * ViewEdge_pointsEnd( BPy_ViewEdge *self, PyObject *args );
/*----------------------ViewEdge instance definitions ----------------------------*/
static PyMethodDef BPy_ViewEdge_methods[] = {
{"A", ( PyCFunction ) ViewEdge_A, METH_NOARGS, "() Returns the first ViewVertex."},
{"B", ( PyCFunction ) ViewEdge_B, METH_NOARGS, "() Returns the second ViewVertex."},
{"fedgeA", ( PyCFunction ) ViewEdge_fedgeA, METH_NOARGS, "() Returns the first FEdge that constitues this ViewEdge."},
{"fedgeB", ( PyCFunction ) ViewEdge_fedgeB, METH_NOARGS, "() Returns the last FEdge that constitues this ViewEdge."},
{"viewShape", ( PyCFunction ) ViewEdge_viewShape, METH_NOARGS, "() Returns the ViewShape to which this ViewEdge belongs to . "},
{"aShape", ( PyCFunction ) ViewEdge_aShape, METH_NOARGS, "() Returns the shape that is occluded by the ViewShape to which this ViewEdge belongs to. If no object is occluded, 0 is returned."},
{"isClosed", ( PyCFunction ) ViewEdge_isClosed, METH_NOARGS, "() Tells whether this ViewEdge forms a closed loop or not."},
{"getChainingTimeStamp", ( PyCFunction ) ViewEdge_getChainingTimeStamp, METH_NOARGS, "() Returns the time stamp of this ViewEdge."},
{"setChainingTimeStamp", ( PyCFunction ) ViewEdge_setChainingTimeStamp, METH_VARARGS, "(int ts) Sets the time stamp value."},
{"setA", ( PyCFunction ) ViewEdge_setA, METH_VARARGS, "(ViewVertex sv) Sets the first ViewVertex of the ViewEdge."},
{"setB", ( PyCFunction ) ViewEdge_setB, METH_VARARGS, "(ViewVertex sv) Sets the last ViewVertex of the ViewEdge."},
{"setNature", ( PyCFunction ) ViewEdge_setNature, METH_VARARGS, "(Nature n) Sets the nature of the ViewEdge."},
{"setFEdgeA", ( PyCFunction ) ViewEdge_setFEdgeA, METH_VARARGS, "(FEdge fe) Sets the first FEdge of the ViewEdge."},
{"setFEdgeB", ( PyCFunction ) ViewEdge_setFEdgeB, METH_VARARGS, "(FEdge fe) Sets the last FEdge of the ViewEdge."},
{"setShape", ( PyCFunction ) ViewEdge_setShape, METH_VARARGS, "(ViewShape vs) Sets the ViewShape to which this ViewEdge belongs to."},
{"setId", ( PyCFunction ) ViewEdge_setId, METH_VARARGS, "(Id id) Sets the ViewEdge id."},
{"UpdateFEdges", ( PyCFunction ) ViewEdge_UpdateFEdges, METH_NOARGS, "() Sets ViewEdge to this for all embedded fedges"},
{"setaShape", ( PyCFunction ) ViewEdge_setaShape, METH_VARARGS, "(ViewShape vs) Sets the occluded ViewShape"},
{"setQI", ( PyCFunction ) ViewEdge_setQI, METH_VARARGS, "(int qi) Sets the quantitative invisibility value."},
{"verticesBegin", ( PyCFunction ) ViewEdge_verticesBegin, METH_NOARGS, "() Returns an Interface0DIterator to iterate over the SVertex constituing the embedding of this ViewEdge. The returned Interface0DIterator points to the first SVertex of the ViewEdge."},
{"verticesEnd", ( PyCFunction ) ViewEdge_verticesEnd, METH_NOARGS, "() Returns an Interface0DIterator to iterate over the SVertex constituing the embedding of this ViewEdge. The returned Interface0DIterator points after the last SVertex of the ViewEdge."},
{"pointsBegin", ( PyCFunction ) ViewEdge_pointsBegin, METH_VARARGS, "(float t=0) Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given resolution t. The returned Interface0DIterator points on the first Point of the ViewEdge."},
{"pointsEnd", ( PyCFunction ) ViewEdge_pointsEnd, METH_VARARGS, "(float t=0) Returns an Interface0DIterator to iterate over the points of this ViewEdge at a given resolution t. The returned Interface0DIterator points after the last Point of the ViewEdge."},
{NULL, NULL, 0, NULL}
};
@@ -120,195 +167,234 @@ int ViewEdge___init__(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
PyObject * ViewEdge_A( BPy_ViewEdge *self ) {
// if( self->ve->A() ){
// return BPy_ViewVertex_from_ViewVertex_ptr( self->ve->A() );
// }
//
Py_RETURN_NONE;
}
PyObject * ViewEdge_B( BPy_ViewEdge *self ) {
// if( self->ve->B() ){
// return BPy_ViewVertex_from_ViewVertex_ptr( self->ve->B() );
// }
if( self->ve->A() ){
return BPy_ViewVertex_from_ViewVertex_ptr( self->ve->A() );
}
Py_RETURN_NONE;
}
//
// PyObject * ViewEdge___getitem__( BPy_ViewEdge *self, PyObject *args ) {
// int i;
//
// if(!( PyArg_ParseTuple(args, "i", &i) && (i == 0 || i == 1) )) {
// cout << "ERROR: ViewEdge___getitem__" << endl;
// Py_RETURN_NONE;
// }
//
// if( SVertex *v = self->ve->operator[](i) )
// return BPy_SVertex_from_SVertex( *v );
//
// Py_RETURN_NONE;
// }
//
// PyObject * ViewEdge_nextEdge( BPy_ViewEdge *self ) {
// if( ViewEdge *fe = self->ve->nextEdge() )
// return BPy_ViewEdge_from_ViewEdge( *fe );
//
// Py_RETURN_NONE;
// }
//
// PyObject * ViewEdge_previousEdge( BPy_ViewEdge *self ) {
// if( ViewEdge *fe = self->ve->previousEdge() )
// return BPy_ViewEdge_from_ViewEdge( *fe );
//
// Py_RETURN_NONE;
// }
//
// PyObject * ViewEdge_isSmooth( BPy_ViewEdge *self ) {
// return PyBool_from_bool( self->ve->isSmooth() );
// }
//
// PyObject *ViewEdge_setVertexA( BPy_ViewEdge *self , PyObject *args) {
// PyObject *py_sv;
//
// if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) {
// cout << "ERROR: ViewEdge_setVertexA" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setVertexA( ((BPy_SVertex *) py_sv)->sv );
//
// Py_RETURN_NONE;
// }
//
// PyObject *ViewEdge_setVertexB( BPy_ViewEdge *self , PyObject *args) {
// PyObject *py_sv;
//
// if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) {
// cout << "ERROR: ViewEdge_setVertexB" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setVertexB( ((BPy_SVertex *) py_sv)->sv );
//
// Py_RETURN_NONE;
// }
//
// PyObject *ViewEdge_setId( BPy_ViewEdge *self , PyObject *args) {
// PyObject *py_id;
//
// if(!( PyArg_ParseTuple(args, "O", &py_id) && BPy_Id_Check(py_id) )) {
// cout << "ERROR: ViewEdge_setId" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setId(*( ((BPy_Id *) py_id)->id ));
//
// Py_RETURN_NONE;
// }
//
//
// PyObject *ViewEdge_setNextEdge( BPy_ViewEdge *self , PyObject *args) {
// PyObject *py_fe;
//
// if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_ViewEdge_Check(py_fe) )) {
// cout << "ERROR: ViewEdge_setNextEdge" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setNextEdge( ((BPy_ViewEdge *) py_fe)->ve );
//
// Py_RETURN_NONE;
// }
//
// PyObject *ViewEdge_setPreviousEdge( BPy_ViewEdge *self , PyObject *args) {
// PyObject *py_fe;
//
// if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_ViewEdge_Check(py_fe) )) {
// cout << "ERROR: ViewEdge_setPreviousEdge" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setPreviousEdge( ((BPy_ViewEdge *) py_fe)->ve );
//
// Py_RETURN_NONE;
// }
//
// PyObject *ViewEdge_setSmooth( BPy_ViewEdge *self , PyObject *args) {
// int b;
//
// if(!( PyArg_ParseTuple(args, "i", &b) )) {
// cout << "ERROR: ViewEdge_setSmooth" << endl;
// Py_RETURN_NONE;
// }
//
// self->ve->setSmooth( (bool) b );
//
// Py_RETURN_NONE;
// }
//
// PyObject * ViewEdge_setNature( BPy_ViewEdge *self, PyObject *args ) {
// PyObject *py_n;
//
// if(!( PyArg_ParseTuple(args, "O", &py_n) && BPy_Nature_Check(py_n) )) {
// cout << "ERROR: ViewEdge_setNature" << endl;
// Py_RETURN_NONE;
// }
//
// PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
// ((ViewEdge *) self->py_if1D.if1D)->setNature( PyInt_AsLong(i) );
//
// Py_RETURN_NONE;
// }
//
// PyObject *ViewEdge_getVertices( BPy_ViewEdge *self ) {
// PyObject *py_vertices = PyList_New(NULL);
//
// for( Interface0DIterator it = self->ve->verticesBegin(); it != self->ve->verticesEnd(); it++ ) {
// PyList_Append( py_vertices, BPy_Interface0D_from_Interface0D( *it ) );
// }
//
// return py_vertices;
// }
//
// PyObject *ViewEdge_getPoints( BPy_ViewEdge *self ) {
// PyObject *py_points = PyList_New(NULL);
//
// for( Interface0DIterator it = self->ve->pointsBegin(); it != self->ve->pointsEnd(); it++ ) {
// PyList_Append( py_points, BPy_Interface0D_from_Interface0D( *it ) );
// }
//
// return py_points;
// }
//
//
//
//
//
// FEdge * fedgeA ()
// FEdge * fedgeB ()
// ViewShape * viewShape ()
// ViewShape * aShape ()
// bool isClosed ()
// unsigned getChainingTimeStamp ()
// void SetA (ViewVertex *iA)
// void SetB (ViewVertex *iB)
// void SetNature (Nature::EdgeNature iNature)
// void SetFEdgeA (FEdge *iFEdge)
// void SetFEdgeB (FEdge *iFEdge)
// void SetShape (ViewShape *iVShape)
// void SetId (const Id &id)
// void UpdateFEdges ()
// void SetaShape (ViewShape *iShape)
// void SetQI (int qi)
// void setChainingTimeStamp (unsigned ts)
// real getLength2D () const
// virtual Interface0DIterator verticesBegin ()
// virtual Interface0DIterator verticesEnd ()
// virtual Interface0DIterator pointsBegin (float t=0.f)
// virtual Interface0DIterator pointsEnd (float t=0.f)
PyObject * ViewEdge_B( BPy_ViewEdge *self ) {
if( self->ve->B() ){
return BPy_ViewVertex_from_ViewVertex_ptr( self->ve->B() );
}
Py_RETURN_NONE;
}
PyObject * ViewEdge_fedgeA( BPy_ViewEdge *self ) {
if( self->ve->fedgeA() ){
return BPy_FEdge_from_FEdge(*( self->ve->fedgeA() ));
}
Py_RETURN_NONE;
}
PyObject * ViewEdge_fedgeB( BPy_ViewEdge *self ) {
if( self->ve->fedgeB() ){
return BPy_FEdge_from_FEdge(*( self->ve->fedgeB() ));
}
Py_RETURN_NONE;
}
PyObject * ViewEdge_viewShape( BPy_ViewEdge *self ) {
if( self->ve->viewShape() ){
return BPy_ViewShape_from_ViewShape(*( self->ve->viewShape() ));
}
Py_RETURN_NONE;
}
PyObject * ViewEdge_aShape( BPy_ViewEdge *self ) {
if( self->ve->aShape() ){
return BPy_ViewShape_from_ViewShape(*( self->ve->aShape() ));
}
Py_RETURN_NONE;
}
PyObject * ViewEdge_isClosed( BPy_ViewEdge *self ) {
return PyBool_from_bool( self->ve->isClosed() );
}
PyObject * ViewEdge_getChainingTimeStamp( BPy_ViewEdge *self ) {
return PyInt_FromLong( self->ve->getChainingTimeStamp() );
}
PyObject * ViewEdge_setChainingTimeStamp( BPy_ViewEdge *self, PyObject *args) {
int timestamp = 0 ;
if( !PyArg_ParseTuple(args, "i", &timestamp) ) {
cout << "ERROR: ViewEdge_setChainingTimeStamp" << endl;
Py_RETURN_NONE;
}
self->ve->setChainingTimeStamp( timestamp );
Py_RETURN_NONE;
}
PyObject *ViewEdge_setA( BPy_ViewEdge *self , PyObject *args) {
PyObject *py_vv;
if(!( PyArg_ParseTuple(args, "O", &py_vv) && BPy_ViewVertex_Check(py_vv) )) {
cout << "ERROR: ViewEdge_setA" << endl;
Py_RETURN_NONE;
}
self->ve->setA( ((BPy_ViewVertex *) py_vv)->vv );
Py_RETURN_NONE;
}
PyObject *ViewEdge_setB( BPy_ViewEdge *self , PyObject *args) {
PyObject *py_vv;
if(!( PyArg_ParseTuple(args, "O", &py_vv) && BPy_ViewVertex_Check(py_vv) )) {
cout << "ERROR: ViewEdge_setB" << endl;
Py_RETURN_NONE;
}
self->ve->setB( ((BPy_ViewVertex *) py_vv)->vv );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setNature( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_n;
if(!( PyArg_ParseTuple(args, "O", &py_n) && BPy_Nature_Check(py_n) )) {
cout << "ERROR: ViewEdge_setNature" << endl;
Py_RETURN_NONE;
}
PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
self->ve->setNature( PyInt_AsLong(i) );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setFEdgeA( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_fe;
if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_FEdge_Check(py_fe) )) {
cout << "ERROR: ViewEdge_setFEdgeA" << endl;
Py_RETURN_NONE;
}
self->ve->setFEdgeA( ((BPy_FEdge *) py_fe)->fe );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setFEdgeB( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_fe;
if(!( PyArg_ParseTuple(args, "O", &py_fe) && BPy_FEdge_Check(py_fe) )) {
cout << "ERROR: ViewEdge_setFEdgeB" << endl;
Py_RETURN_NONE;
}
self->ve->setFEdgeB( ((BPy_FEdge *) py_fe)->fe );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setShape( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_vs;
if(!( PyArg_ParseTuple(args, "O", &py_vs) && BPy_ViewShape_Check(py_vs) )) {
cout << "ERROR: ViewEdge_setShape" << endl;
Py_RETURN_NONE;
}
self->ve->setShape( ((BPy_ViewShape *) py_vs)->vs );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setId( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_id;
if(!( PyArg_ParseTuple(args, "O", &py_id) && BPy_Id_Check(py_id) )) {
cout << "ERROR: ViewEdge_setId" << endl;
Py_RETURN_NONE;
}
Id id(*( ((BPy_Id *) py_id)->id ));
self->ve->setId( id );
Py_RETURN_NONE;
}
PyObject * ViewEdge_UpdateFEdges( BPy_ViewEdge *self ) {
self->ve->UpdateFEdges();
Py_RETURN_NONE;
}
PyObject * ViewEdge_setaShape( BPy_ViewEdge *self, PyObject *args ) {
PyObject *py_vs;
if(!( PyArg_ParseTuple(args, "O", &py_vs) && BPy_ViewShape_Check(py_vs) )) {
cout << "ERROR: ViewEdge_setaShape" << endl;
Py_RETURN_NONE;
}
ViewShape *vs = ((BPy_ViewShape *) py_vs)->vs;
self->ve->setaShape( vs );
Py_RETURN_NONE;
}
PyObject * ViewEdge_setQI( BPy_ViewEdge *self, PyObject *args ) {
int qi;
if(!( PyArg_ParseTuple(args, "i", &qi) )) {
cout << "ERROR: ViewEdge_setQI" << endl;
Py_RETURN_NONE;
}
self->ve->setQI( qi );
Py_RETURN_NONE;
}
PyObject * ViewEdge_verticesBegin( BPy_ViewEdge *self ) {
Interface0DIterator if0D_it( self->ve->verticesBegin() );
return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it );
}
PyObject * ViewEdge_verticesEnd( BPy_ViewEdge *self ) {
Interface0DIterator if0D_it( self->ve->verticesEnd() );
return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it );
}
PyObject * ViewEdge_pointsBegin( BPy_ViewEdge *self, PyObject *args ) {
float f = 0;
if(!( PyArg_ParseTuple(args, "|f", &f) )) {
cout << "ERROR: ViewEdge_pointsBegin" << endl;
Py_RETURN_NONE;
}
Interface0DIterator if0D_it( self->ve->pointsBegin(f) );
return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it );
}
PyObject * ViewEdge_pointsEnd( BPy_ViewEdge *self, PyObject *args ) {
float f = 0;
if(!( PyArg_ParseTuple(args, "|f", &f) )) {
cout << "ERROR: ViewEdge_pointsEnd" << endl;
Py_RETURN_NONE;
}
Interface0DIterator if0D_it( self->ve->pointsEnd(f) );
return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it );
}
///////////////////////////////////////////////////////////////////////////////////////////