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

soc-2008-mxcurioni: ported ALL 1D unary functions, representing 32 new classes.

Browse Source
This commit is contained in:
Maxime Curioni
2008-07-27 11:27:59 +00:00
parent 0cc6f9db3d
commit 2b2df54aef
83 changed files with 5761 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
source/blender/freestyle/SConscript
View File

@@ -138,6 +138,39 @@ python_sources = [
prefix + '/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetOccludeeF0D.cpp',
prefix + '/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetShapeF0D.cpp',
prefix + '/BPy_UnaryFunction1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp',
prefix + '/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp',
prefix + '/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp',
prefix + '/BPy_UnaryPredicate0D.cpp',
prefix + '/BPy_UnaryPredicate1D.cpp',
prefix + '/BPy_ViewMap.cpp',

16
source/blender/freestyle/intern/python/BPy_Convert.cpp
View File

@@ -189,6 +189,22 @@ PyObject * BPy_FrsMaterial_from_Material( Material& m ){
return py_m;
}
PyObject * BPy_IntegrationType_from_IntegrationType( int i ) {
PyObject *py_it = IntegrationType_Type.tp_new( &IntegrationType_Type, 0, 0 );
PyObject *args = PyTuple_New(1);
PyTuple_SetItem( args, 0, PyInt_FromLong(i) );
IntegrationType_Type.tp_init( py_it, args, 0 );
Py_DECREF(args);
return py_it;
}
IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj ) {
return static_cast<IntegrationType>( PyInt_AsLong(obj) );
}
///////////////////////////////////////////////////////////////////////////////////////////

3
source/blender/freestyle/intern/python/BPy_Convert.h
View File

@@ -58,10 +58,13 @@ PyObject * Vector_from_Vec2f( Vec2f& v );
PyObject * Vector_from_Vec3f( Vec3f& v );
PyObject * Vector_from_Vec3r( Vec3r& v );
IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj );
PyObject * BPy_BBox_from_BBox( BBox< Vec3r > &bb );
PyObject * BPy_FEdge_from_FEdge( FEdge& fe );
PyObject * BPy_Id_from_Id( Id& id );
PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
PyObject * BPy_IntegrationType_from_IntegrationType( int i );
PyObject * BPy_FrsMaterial_from_Material( Material& m );
PyObject * BPy_Nature_from_Nature( unsigned short n );
PyObject * BPy_MediumType_from_MediumType( int n );

66
source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp
View File

@@ -1,6 +1,13 @@
#include "BPy_UnaryFunction1D.h"
#include "BPy_Convert.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DDouble.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DFloat.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DVec2f.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DVec3f.h"
#include "UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h"
#ifdef __cplusplus
extern "C" {
@@ -9,17 +16,11 @@ extern "C" {
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1D instance -----------*/
static int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds);
static void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D *self);
static PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D *self);
static PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args);
static PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args);
/*----------------------UnaryFunction1D instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1D_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1D_getName, METH_NOARGS, ""},
{"__call__", ( PyCFunction ) UnaryFunction1D___call__, METH_VARARGS, "" },
{NULL, NULL, 0, NULL}
};
@@ -73,7 +74,7 @@ PyTypeObject UnaryFunction1D_Type = {
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
NULL, /* long tp_weaklistoffset; */
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
@@ -88,8 +89,8 @@ PyTypeObject UnaryFunction1D_Type = {
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
NULL, /* long tp_dictoffset; */
(initproc)UnaryFunction1D___init__, /* initproc tp_init; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
PyType_GenericNew, /* newfunc tp_new; */
@@ -118,56 +119,29 @@ PyMODINIT_FUNC UnaryFunction1D_Init( PyObject *module )
return;
Py_INCREF( &UnaryFunction1D_Type );
PyModule_AddObject(module, "UnaryFunction1D", (PyObject *)&UnaryFunction1D_Type);
UnaryFunction1DDouble_Init( module );
UnaryFunction1DEdgeNature_Init( module );
UnaryFunction1DFloat_Init( module );
UnaryFunction1DUnsigned_Init( module );
UnaryFunction1DVec2f_Init( module );
UnaryFunction1DVec3f_Init( module );
UnaryFunction1DVectorViewShape_Init( module );
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds)
{
return 0;
}
void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D* self)
{
//delete self->uf1D;
self->ob_type->tp_free((PyObject*)self);
}
PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D* self)
{
return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction1D<void> *) self->uf1D)->getName().c_str(), self->uf1D );
return PyString_FromString("UnaryFunction1D");
}
PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args)
{
return PyString_FromString( ((UnaryFunction1D<void> *) self->uf1D)->getName().c_str() );
}
PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args)
{
PyObject *l;
if( !PyArg_ParseTuple(args, "O", &l) ) {
cout << "ERROR: UnaryFunction1D___call__ " << endl;
return NULL;
}
// pb: operator() is called on Interface0DIterator while we have a list
// solutions:
// 1)reconvert back to iterator ?
// 2) adapt interface0d to have t(), u() functions
// b = self->bp0D->operator()( *(obj1->uf0D) );
// return PyBool_from_bool( b );
Py_RETURN_NONE;
}
// void setIntegrationType (IntegrationType integration)
// IntegrationType getIntegrationType () const
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus

1
source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h
View File

@@ -18,7 +18,6 @@ extern PyTypeObject UnaryFunction1D_Type;
/*---------------------------Python BPy_UnaryFunction1D structure definition----------*/
typedef struct {
PyObject_HEAD
void *uf1D;
} BPy_UnaryFunction1D;
/*---------------------------Python BPy_UnaryFunction1D visible prototypes-----------*/

2
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp
View File

@@ -168,7 +168,7 @@ PyObject * UnaryFunction0DVectorViewShape___call__( BPy_UnaryFunction0DVectorVie
std::vector<ViewShape*> vs( self->uf0D_vectorviewshape->operator()(*( ((BPy_Interface0DIterator *) obj)->if0D_it )) );
PyObject *list = PyList_New(NULL);
for( int i = 0; i < vs.size(); i++)
for( unsigned int i = 0; i < vs.size(); i++)
PyList_Append(list, BPy_ViewShape_from_ViewShape(*( vs[i] )) );
return list;

291
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp
View File

@@ -1,20 +1,285 @@
PyObject *_wrap_UnaryFunction1DDouble_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DDouble.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h"
#include "UnaryFunction1D_double/BPy_DensityF1D.h"
#include "UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h"
#include "UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h"
#include "UnaryFunction1D_double/BPy_GetProjectedXF1D.h"
#include "UnaryFunction1D_double/BPy_GetProjectedYF1D.h"
#include "UnaryFunction1D_double/BPy_GetProjectedZF1D.h"
#include "UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h"
#include "UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h"
#include "UnaryFunction1D_double/BPy_GetXF1D.h"
#include "UnaryFunction1D_double/BPy_GetYF1D.h"
#include "UnaryFunction1D_double/BPy_GetZF1D.h"
#include "UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h"
#include "UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DDouble instance -----------*/
static int UnaryFunction1DDouble___init__(BPy_UnaryFunction1DDouble* self, PyObject *args);
static void UnaryFunction1DDouble___dealloc__(BPy_UnaryFunction1DDouble* self);
static PyObject * UnaryFunction1DDouble___repr__(BPy_UnaryFunction1DDouble* self);
static PyObject * UnaryFunction1DDouble_getName( BPy_UnaryFunction1DDouble *self);
static PyObject * UnaryFunction1DDouble___call__( BPy_UnaryFunction1DDouble *self, PyObject *args);
static PyObject * UnaryFunction1DDouble_setIntegrationType(BPy_UnaryFunction1DDouble* self, PyObject *args);
static PyObject * UnaryFunction1DDouble_getIntegrationType(BPy_UnaryFunction1DDouble* self);
/*----------------------UnaryFunction1DDouble instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DDouble_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DDouble_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DDouble___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DDouble_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DDouble_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DDouble type definition ------------------------------*/
PyTypeObject UnaryFunction1DDouble_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DDouble", /* tp_name */
sizeof( BPy_UnaryFunction1DDouble ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DDouble___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DDouble___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DDouble_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DDouble___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DDouble_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DDouble_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DDouble_Type );
PyModule_AddObject(module, "UnaryFunction1DDouble", (PyObject *)&UnaryFunction1DDouble_Type);
if( PyType_Ready( &DensityF1D_Type ) < 0 )
return;
Py_INCREF( &DensityF1D_Type );
PyModule_AddObject(module, "DensityF1D", (PyObject *)&DensityF1D_Type);
if( PyType_Ready( &GetCompleteViewMapDensityF1D_Type ) < 0 )
return;
Py_INCREF( &GetCompleteViewMapDensityF1D_Type );
PyModule_AddObject(module, "GetCompleteViewMapDensityF1D", (PyObject *)&GetCompleteViewMapDensityF1D_Type);
if( PyType_Ready( &GetDirectionalViewMapDensityF1D_Type ) < 0 )
return;
Py_INCREF( &GetDirectionalViewMapDensityF1D_Type );
PyModule_AddObject(module, "GetDirectionalViewMapDensityF1D", (PyObject *)&GetDirectionalViewMapDensityF1D_Type);
if( PyType_Ready( &GetProjectedXF1D_Type ) < 0 )
return;
Py_INCREF( &GetProjectedXF1D_Type );
PyModule_AddObject(module, "GetProjectedXF1D", (PyObject *)&GetProjectedXF1D_Type);
if( PyType_Ready( &GetProjectedYF1D_Type ) < 0 )
return;
Py_INCREF( &GetProjectedYF1D_Type );
PyModule_AddObject(module, "GetProjectedYF1D", (PyObject *)&GetProjectedYF1D_Type);
if( PyType_Ready( &GetProjectedZF1D_Type ) < 0 )
return;
Py_INCREF( &GetProjectedZF1D_Type );
PyModule_AddObject(module, "GetProjectedZF1D", (PyObject *)&GetProjectedZF1D_Type);
if( PyType_Ready( &GetSteerableViewMapDensityF1D_Type ) < 0 )
return;
Py_INCREF( &GetSteerableViewMapDensityF1D_Type );
PyModule_AddObject(module, "GetSteerableViewMapDensityF1D", (PyObject *)&GetSteerableViewMapDensityF1D_Type);
if( PyType_Ready( &GetViewMapGradientNormF1D_Type ) < 0 )
return;
Py_INCREF( &GetViewMapGradientNormF1D_Type );
PyModule_AddObject(module, "GetViewMapGradientNormF1D", (PyObject *)&GetViewMapGradientNormF1D_Type);
if( PyType_Ready( &GetXF1D_Type ) < 0 )
return;
Py_INCREF( &GetXF1D_Type );
PyModule_AddObject(module, "GetXF1D", (PyObject *)&GetXF1D_Type);
if( PyType_Ready( &GetYF1D_Type ) < 0 )
return;
Py_INCREF( &GetYF1D_Type );
PyModule_AddObject(module, "GetYF1D", (PyObject *)&GetYF1D_Type);
if( PyType_Ready( &GetZF1D_Type ) < 0 )
return;
Py_INCREF( &GetZF1D_Type );
PyModule_AddObject(module, "GetZF1D", (PyObject *)&GetZF1D_Type);
if( PyType_Ready( &LocalAverageDepthF1D_Type ) < 0 )
return;
Py_INCREF( &LocalAverageDepthF1D_Type );
PyModule_AddObject(module, "LocalAverageDepthF1D", (PyObject *)&LocalAverageDepthF1D_Type);
if( PyType_Ready( &ZDiscontinuityF1D_Type ) < 0 )
return;
Py_INCREF( &ZDiscontinuityF1D_Type );
PyModule_AddObject(module, "ZDiscontinuityF1D", (PyObject *)&ZDiscontinuityF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DDouble___init__(BPy_UnaryFunction1DDouble* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DDouble___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_double = new UnaryFunction1D<double>();
else {
self->uf1D_double = new UnaryFunction1D<double>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DDouble___dealloc__(BPy_UnaryFunction1DDouble* self)
{
delete self->uf1D_double;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DDouble___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DDouble___repr__(BPy_UnaryFunction1DDouble* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_double->getName().c_str(), self->uf1D_double );
}
PyObject * UnaryFunction1DDouble_getName( BPy_UnaryFunction1DDouble *self )
{
return PyString_FromString( self->uf1D_double->getName().c_str() );
}
PyObject * UnaryFunction1DDouble___call__( BPy_UnaryFunction1DDouble *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DDouble___call__ " << endl;
return NULL;
}
double d = self->uf1D_double->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
return PyFloat_FromDouble( d );
}
PyObject * UnaryFunction1DDouble_setIntegrationType(BPy_UnaryFunction1DDouble* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DDouble_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_double->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DDouble_getIntegrationType(BPy_UnaryFunction1DDouble* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_double->getIntegrationType() );
}
PyObject *_wrap_UnaryFunction1DDouble_setIntegrationType(PyObject *self , PyObject *args) {
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
PyObject *_wrap_UnaryFunction1DDouble_getIntegrationType(PyObject *self , PyObject *args) {
}
PyObject *_wrap_disown_UnaryFunction1DDouble(PyObject *self , PyObject *args) {
}
#endif

34
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H
#include "../BPy_UnaryFunction1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DDouble_Type;
#define BPy_UnaryFunction1DDouble_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DDouble_Type)
/*---------------------------Python BPy_UnaryFunction1DDouble structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<double> *uf1D_double;
} BPy_UnaryFunction1DDouble;
/*---------------------------Python BPy_UnaryFunction1DDouble visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DDouble_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DDOUBLE_H */

209
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp Normal file
View File

@@ -0,0 +1,209 @@
#include "BPy_UnaryFunction1DEdgeNature.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DEdgeNature instance -----------*/
static int UnaryFunction1DEdgeNature___init__(BPy_UnaryFunction1DEdgeNature* self, PyObject *args);
static void UnaryFunction1DEdgeNature___dealloc__(BPy_UnaryFunction1DEdgeNature* self);
static PyObject * UnaryFunction1DEdgeNature___repr__(BPy_UnaryFunction1DEdgeNature* self);
static PyObject * UnaryFunction1DEdgeNature_getName( BPy_UnaryFunction1DEdgeNature *self);
static PyObject * UnaryFunction1DEdgeNature___call__( BPy_UnaryFunction1DEdgeNature *self, PyObject *args);
static PyObject * UnaryFunction1DEdgeNature_setIntegrationType(BPy_UnaryFunction1DEdgeNature* self, PyObject *args);
static PyObject * UnaryFunction1DEdgeNature_getIntegrationType(BPy_UnaryFunction1DEdgeNature* self);
/*----------------------UnaryFunction1DEdgeNature instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DEdgeNature_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DEdgeNature_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DEdgeNature___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DEdgeNature_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DEdgeNature_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DEdgeNature type definition ------------------------------*/
PyTypeObject UnaryFunction1DEdgeNature_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DEdgeNature", /* tp_name */
sizeof( BPy_UnaryFunction1DEdgeNature ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DEdgeNature___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DEdgeNature___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DEdgeNature_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DEdgeNature___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DEdgeNature_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DEdgeNature_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DEdgeNature_Type );
PyModule_AddObject(module, "UnaryFunction1DEdgeNature", (PyObject *)&UnaryFunction1DEdgeNature_Type);
if( PyType_Ready( &CurveNatureF1D_Type ) < 0 )
return;
Py_INCREF( &CurveNatureF1D_Type );
PyModule_AddObject(module, "CurveNatureF1D", (PyObject *)&CurveNatureF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DEdgeNature___init__(BPy_UnaryFunction1DEdgeNature* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DEdgeNature___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_edgenature = new UnaryFunction1D<Nature::EdgeNature>();
else {
self->uf1D_edgenature = new UnaryFunction1D<Nature::EdgeNature>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DEdgeNature___dealloc__(BPy_UnaryFunction1DEdgeNature* self)
{
delete self->uf1D_edgenature;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject * UnaryFunction1DEdgeNature___repr__(BPy_UnaryFunction1DEdgeNature* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_edgenature->getName().c_str(), self->uf1D_edgenature );
}
PyObject * UnaryFunction1DEdgeNature_getName( BPy_UnaryFunction1DEdgeNature *self )
{
return PyString_FromString( self->uf1D_edgenature->getName().c_str() );
}
PyObject * UnaryFunction1DEdgeNature___call__( BPy_UnaryFunction1DEdgeNature *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DEdgeNature___call__ " << endl;
return NULL;
}
Nature::EdgeNature n = self->uf1D_edgenature->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
return BPy_Nature_from_Nature( n );
}
PyObject * UnaryFunction1DEdgeNature_setIntegrationType(BPy_UnaryFunction1DEdgeNature* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DEdgeNature_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_edgenature->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DEdgeNature_getIntegrationType(BPy_UnaryFunction1DEdgeNature* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_edgenature->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

36
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H
#include "../BPy_UnaryFunction1D.h"
#include "../../winged_edge/Nature.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DEdgeNature_Type;
#define BPy_UnaryFunction1DEdgeNature_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DEdgeNature_Type)
/*---------------------------Python BPy_UnaryFunction1DEdgeNature structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<Nature::EdgeNature> *uf1D_edgenature;
} BPy_UnaryFunction1DEdgeNature;
/*---------------------------Python BPy_UnaryFunction1DEdgeNature visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DEdgeNature_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DEDGENATURE_H */

194
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp
View File

@@ -1,20 +1,202 @@
PyObject *_wrap_UnaryFunction1DFloat_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DFloat.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DFloat instance -----------*/
static int UnaryFunction1DFloat___init__(BPy_UnaryFunction1DFloat* self, PyObject *args);
static void UnaryFunction1DFloat___dealloc__(BPy_UnaryFunction1DFloat* self);
static PyObject * UnaryFunction1DFloat___repr__(BPy_UnaryFunction1DFloat* self);
static PyObject * UnaryFunction1DFloat_getName( BPy_UnaryFunction1DFloat *self);
static PyObject * UnaryFunction1DFloat___call__( BPy_UnaryFunction1DFloat *self, PyObject *args);
static PyObject * UnaryFunction1DFloat_setIntegrationType(BPy_UnaryFunction1DFloat* self, PyObject *args);
static PyObject * UnaryFunction1DFloat_getIntegrationType(BPy_UnaryFunction1DFloat* self);
/*----------------------UnaryFunction1DFloat instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DFloat_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DFloat_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DFloat___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DFloat_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DFloat_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DFloat type definition ------------------------------*/
PyTypeObject UnaryFunction1DFloat_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DFloat", /* tp_name */
sizeof( BPy_UnaryFunction1DFloat ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DFloat___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DFloat___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DFloat_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DFloat___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DFloat_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DFloat_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DFloat_Type );
PyModule_AddObject(module, "UnaryFunction1DFloat", (PyObject *)&UnaryFunction1DFloat_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DFloat___init__(BPy_UnaryFunction1DFloat* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DFloat___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_float = new UnaryFunction1D<float>();
else {
self->uf1D_float = new UnaryFunction1D<float>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DFloat___dealloc__(BPy_UnaryFunction1DFloat* self)
{
delete self->uf1D_float;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DFloat___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DFloat___repr__(BPy_UnaryFunction1DFloat* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_float->getName().c_str(), self->uf1D_float );
}
PyObject *_wrap_UnaryFunction1DFloat_setIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DFloat_getName( BPy_UnaryFunction1DFloat *self )
{
return PyString_FromString( self->uf1D_float->getName().c_str() );
}
PyObject * UnaryFunction1DFloat___call__( BPy_UnaryFunction1DFloat *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DFloat___call__ " << endl;
return NULL;
}
float f = self->uf1D_float->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
return PyFloat_FromDouble( f );
PyObject *_wrap_UnaryFunction1DFloat_getIntegrationType(PyObject *self , PyObject *args) {
}
PyObject * UnaryFunction1DFloat_setIntegrationType(BPy_UnaryFunction1DFloat* self, PyObject *args)
{
PyObject *obj;
PyObject *_wrap_disown_UnaryFunction1DFloat(PyObject *self , PyObject *args) {
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DFloat_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_float->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DFloat_getIntegrationType(BPy_UnaryFunction1DFloat* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_float->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

34
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H
#include "../BPy_UnaryFunction1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DFloat_Type;
#define BPy_UnaryFunction1DFloat_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DFloat_Type)
/*---------------------------Python BPy_UnaryFunction1DFloat structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<float> *uf1D_float;
} BPy_UnaryFunction1DFloat;
/*---------------------------Python BPy_UnaryFunction1DFloat visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DFloat_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DFLOAT_H */

201
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp
View File

@@ -1,20 +1,209 @@
PyObject *_wrap_UnaryFunction1DUnsigned_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DUnsigned.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DUnsigned instance -----------*/
static int UnaryFunction1DUnsigned___init__(BPy_UnaryFunction1DUnsigned* self, PyObject *args);
static void UnaryFunction1DUnsigned___dealloc__(BPy_UnaryFunction1DUnsigned* self);
static PyObject * UnaryFunction1DUnsigned___repr__(BPy_UnaryFunction1DUnsigned* self);
static PyObject * UnaryFunction1DUnsigned_getName( BPy_UnaryFunction1DUnsigned *self);
static PyObject * UnaryFunction1DUnsigned___call__( BPy_UnaryFunction1DUnsigned *self, PyObject *args);
static PyObject * UnaryFunction1DUnsigned_setIntegrationType(BPy_UnaryFunction1DUnsigned* self, PyObject *args);
static PyObject * UnaryFunction1DUnsigned_getIntegrationType(BPy_UnaryFunction1DUnsigned* self);
/*----------------------UnaryFunction1DUnsigned instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DUnsigned_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DUnsigned_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DUnsigned___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DUnsigned_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DUnsigned_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DUnsigned type definition ------------------------------*/
PyTypeObject UnaryFunction1DUnsigned_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DUnsigned", /* tp_name */
sizeof( BPy_UnaryFunction1DUnsigned ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DUnsigned___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DUnsigned___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DUnsigned_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DUnsigned___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DUnsigned_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DUnsigned_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DUnsigned_Type );
PyModule_AddObject(module, "UnaryFunction1DUnsigned", (PyObject *)&UnaryFunction1DUnsigned_Type);
if( PyType_Ready( &QuantitativeInvisibilityF1D_Type ) < 0 )
return;
Py_INCREF( &QuantitativeInvisibilityF1D_Type );
PyModule_AddObject(module, "QuantitativeInvisibilityF1D", (PyObject *)&QuantitativeInvisibilityF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DUnsigned___init__(BPy_UnaryFunction1DUnsigned* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DUnsigned___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_unsigned = new UnaryFunction1D<unsigned int>();
else {
self->uf1D_unsigned = new UnaryFunction1D<unsigned int>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DUnsigned___dealloc__(BPy_UnaryFunction1DUnsigned* self)
{
delete self->uf1D_unsigned;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DUnsigned___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DUnsigned___repr__(BPy_UnaryFunction1DUnsigned* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_unsigned->getName().c_str(), self->uf1D_unsigned );
}
PyObject *_wrap_UnaryFunction1DUnsigned_setIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DUnsigned_getName( BPy_UnaryFunction1DUnsigned *self )
{
return PyString_FromString( self->uf1D_unsigned->getName().c_str() );
}
PyObject * UnaryFunction1DUnsigned___call__( BPy_UnaryFunction1DUnsigned *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DUnsigned___call__ " << endl;
return NULL;
}
unsigned int i = self->uf1D_unsigned->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
return PyInt_FromLong( i );
PyObject *_wrap_UnaryFunction1DUnsigned_getIntegrationType(PyObject *self , PyObject *args) {
}
PyObject * UnaryFunction1DUnsigned_setIntegrationType(BPy_UnaryFunction1DUnsigned* self, PyObject *args)
{
PyObject *obj;
PyObject *_wrap_disown_UnaryFunction1DUnsigned(PyObject *self , PyObject *args) {
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DUnsigned_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_unsigned->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DUnsigned_getIntegrationType(BPy_UnaryFunction1DUnsigned* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_unsigned->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

34
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H
#include "../BPy_UnaryFunction1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DUnsigned_Type;
#define BPy_UnaryFunction1DUnsigned_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DUnsigned_Type)
/*---------------------------Python BPy_UnaryFunction1DUnsigned structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<unsigned int> *uf1D_unsigned;
} BPy_UnaryFunction1DUnsigned;
/*---------------------------Python BPy_UnaryFunction1DUnsigned visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DUnsigned_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DUNSIGNED_H */

207
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp
View File

@@ -1,20 +1,215 @@
PyObject *_wrap_UnaryFunction1DVec2f_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DVec2f.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h"
#include "UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DVec2f instance -----------*/
static int UnaryFunction1DVec2f___init__(BPy_UnaryFunction1DVec2f* self, PyObject *args);
static void UnaryFunction1DVec2f___dealloc__(BPy_UnaryFunction1DVec2f* self);
static PyObject * UnaryFunction1DVec2f___repr__(BPy_UnaryFunction1DVec2f* self);
static PyObject * UnaryFunction1DVec2f_getName( BPy_UnaryFunction1DVec2f *self);
static PyObject * UnaryFunction1DVec2f___call__( BPy_UnaryFunction1DVec2f *self, PyObject *args);
static PyObject * UnaryFunction1DVec2f_setIntegrationType(BPy_UnaryFunction1DVec2f* self, PyObject *args);
static PyObject * UnaryFunction1DVec2f_getIntegrationType(BPy_UnaryFunction1DVec2f* self);
/*----------------------UnaryFunction1DVec2f instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DVec2f_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DVec2f_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DVec2f___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVec2f_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVec2f_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DVec2f type definition ------------------------------*/
PyTypeObject UnaryFunction1DVec2f_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DVec2f", /* tp_name */
sizeof( BPy_UnaryFunction1DVec2f ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DVec2f___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DVec2f___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DVec2f_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DVec2f___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DVec2f_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DVec2f_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DVec2f_Type );
PyModule_AddObject(module, "UnaryFunction1DVec2f", (PyObject *)&UnaryFunction1DVec2f_Type);
if( PyType_Ready( &Normal2DF1D_Type ) < 0 )
return;
Py_INCREF( &Normal2DF1D_Type );
PyModule_AddObject(module, "Normal2DF1D", (PyObject *)&Normal2DF1D_Type);
if( PyType_Ready( &Orientation2DF1D_Type ) < 0 )
return;
Py_INCREF( &Orientation2DF1D_Type );
PyModule_AddObject(module, "Orientation2DF1D", (PyObject *)&Orientation2DF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DVec2f___init__(BPy_UnaryFunction1DVec2f* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec2f___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_vec2f = new UnaryFunction1D<Vec2f>();
else {
self->uf1D_vec2f = new UnaryFunction1D<Vec2f>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DVec2f___dealloc__(BPy_UnaryFunction1DVec2f* self)
{
delete self->uf1D_vec2f;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DVec2f___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVec2f___repr__(BPy_UnaryFunction1DVec2f* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_vec2f->getName().c_str(), self->uf1D_vec2f );
}
PyObject *_wrap_UnaryFunction1DVec2f_setIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVec2f_getName( BPy_UnaryFunction1DVec2f *self )
{
return PyString_FromString( self->uf1D_vec2f->getName().c_str() );
}
PyObject * UnaryFunction1DVec2f___call__( BPy_UnaryFunction1DVec2f *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec2f___call__ " << endl;
return NULL;
}
Vec2f v( self->uf1D_vec2f->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
return Vector_from_Vec2f( v );
PyObject *_wrap_UnaryFunction1DVec2f_getIntegrationType(PyObject *self , PyObject *args) {
}
PyObject * UnaryFunction1DVec2f_setIntegrationType(BPy_UnaryFunction1DVec2f* self, PyObject *args)
{
PyObject *obj;
PyObject *_wrap_disown_UnaryFunction1DVec2f(PyObject *self , PyObject *args) {
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec2f_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_vec2f->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DVec2f_getIntegrationType(BPy_UnaryFunction1DVec2f* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_vec2f->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

37
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H
#include "../BPy_UnaryFunction1D.h"
#include "../../geometry/Geom.h"
using namespace Geometry;
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DVec2f_Type;
#define BPy_UnaryFunction1DVec2f_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DVec2f_Type)
/*---------------------------Python BPy_UnaryFunction1DVec2f structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<Vec2f> *uf1D_vec2f;
} BPy_UnaryFunction1DVec2f;
/*---------------------------Python BPy_UnaryFunction1DVec2f visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DVec2f_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVEC2F_H */

201
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp
View File

@@ -1,20 +1,209 @@
PyObject *_wrap_UnaryFunction1DVec3f_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DVec3f.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DVec3f instance -----------*/
static int UnaryFunction1DVec3f___init__(BPy_UnaryFunction1DVec3f* self, PyObject *args);
static void UnaryFunction1DVec3f___dealloc__(BPy_UnaryFunction1DVec3f* self);
static PyObject * UnaryFunction1DVec3f___repr__(BPy_UnaryFunction1DVec3f* self);
static PyObject * UnaryFunction1DVec3f_getName( BPy_UnaryFunction1DVec3f *self);
static PyObject * UnaryFunction1DVec3f___call__( BPy_UnaryFunction1DVec3f *self, PyObject *args);
static PyObject * UnaryFunction1DVec3f_setIntegrationType(BPy_UnaryFunction1DVec3f* self, PyObject *args);
static PyObject * UnaryFunction1DVec3f_getIntegrationType(BPy_UnaryFunction1DVec3f* self);
/*----------------------UnaryFunction1DVec3f instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DVec3f_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DVec3f_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DVec3f___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVec3f_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVec3f_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DVec3f type definition ------------------------------*/
PyTypeObject UnaryFunction1DVec3f_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DVec3f", /* tp_name */
sizeof( BPy_UnaryFunction1DVec3f ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DVec3f___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DVec3f___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DVec3f_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DVec3f___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DVec3f_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DVec3f_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DVec3f_Type );
PyModule_AddObject(module, "UnaryFunction1DVec3f", (PyObject *)&UnaryFunction1DVec3f_Type);
if( PyType_Ready( &Orientation3DF1D_Type ) < 0 )
return;
Py_INCREF( &Orientation3DF1D_Type );
PyModule_AddObject(module, "Orientation3DF1D", (PyObject *)&Orientation3DF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DVec3f___init__(BPy_UnaryFunction1DVec3f* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec3f___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_vec3f = new UnaryFunction1D<Vec3f>();
else {
self->uf1D_vec3f = new UnaryFunction1D<Vec3f>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DVec3f___dealloc__(BPy_UnaryFunction1DVec3f* self)
{
delete self->uf1D_vec3f;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DVec3f___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVec3f___repr__(BPy_UnaryFunction1DVec3f* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_vec3f->getName().c_str(), self->uf1D_vec3f );
}
PyObject *_wrap_UnaryFunction1DVec3f_setIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVec3f_getName( BPy_UnaryFunction1DVec3f *self )
{
return PyString_FromString( self->uf1D_vec3f->getName().c_str() );
}
PyObject * UnaryFunction1DVec3f___call__( BPy_UnaryFunction1DVec3f *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec3f___call__ " << endl;
return NULL;
}
Vec3f v( self->uf1D_vec3f->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
return Vector_from_Vec3f( v );
PyObject *_wrap_UnaryFunction1DVec3f_getIntegrationType(PyObject *self , PyObject *args) {
}
PyObject * UnaryFunction1DVec3f_setIntegrationType(BPy_UnaryFunction1DVec3f* self, PyObject *args)
{
PyObject *obj;
PyObject *_wrap_disown_UnaryFunction1DVec3f(PyObject *self , PyObject *args) {
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVec3f_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_vec3f->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DVec3f_getIntegrationType(BPy_UnaryFunction1DVec3f* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_vec3f->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

37
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H
#include "../BPy_UnaryFunction1D.h"
#include "../../geometry/Geom.h"
using namespace Geometry;
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DVec3f_Type;
#define BPy_UnaryFunction1DVec3f_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DVec3f_Type)
/*---------------------------Python BPy_UnaryFunction1DVec3f structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<Vec3f> *uf1D_vec3f;
} BPy_UnaryFunction1DVec3f;
/*---------------------------Python BPy_UnaryFunction1DVec3f visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DVec3f_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVEC3F_H */

222
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp
View File

@@ -1,16 +1,228 @@
PyObject *_wrap_UnaryFunction1DVectorViewShape_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction1DVectorViewShape.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h"
#include "UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h"
#include "UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DVectorViewShape instance -----------*/
static int UnaryFunction1DVectorViewShape___init__(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args);
static void UnaryFunction1DVectorViewShape___dealloc__(BPy_UnaryFunction1DVectorViewShape* self);
static PyObject * UnaryFunction1DVectorViewShape___repr__(BPy_UnaryFunction1DVectorViewShape* self);
static PyObject * UnaryFunction1DVectorViewShape_getName( BPy_UnaryFunction1DVectorViewShape *self);
static PyObject * UnaryFunction1DVectorViewShape___call__( BPy_UnaryFunction1DVectorViewShape *self, PyObject *args);
static PyObject * UnaryFunction1DVectorViewShape_setIntegrationType(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args);
static PyObject * UnaryFunction1DVectorViewShape_getIntegrationType(BPy_UnaryFunction1DVectorViewShape* self);
/*----------------------UnaryFunction1DVectorViewShape instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DVectorViewShape_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DVectorViewShape_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DVectorViewShape___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVectorViewShape_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVectorViewShape_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DVectorViewShape type definition ------------------------------*/
PyTypeObject UnaryFunction1DVectorViewShape_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DVectorViewShape", /* tp_name */
sizeof( BPy_UnaryFunction1DVectorViewShape ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DVectorViewShape___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DVectorViewShape___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DVectorViewShape_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DVectorViewShape___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DVectorViewShape_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DVectorViewShape_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DVectorViewShape_Type );
PyModule_AddObject(module, "UnaryFunction1DVectorViewShape", (PyObject *)&UnaryFunction1DVectorViewShape_Type);
if( PyType_Ready( &GetOccludeeF1D_Type ) < 0 )
return;
Py_INCREF( &GetOccludeeF1D_Type );
PyModule_AddObject(module, "GetOccludeeF1D", (PyObject *)&GetOccludeeF1D_Type);
if( PyType_Ready( &GetOccludersF1D_Type ) < 0 )
return;
Py_INCREF( &GetOccludersF1D_Type );
PyModule_AddObject(module, "GetOccludersF1D", (PyObject *)&GetOccludersF1D_Type);
if( PyType_Ready( &GetShapeF1D_Type ) < 0 )
return;
Py_INCREF( &GetShapeF1D_Type );
PyModule_AddObject(module, "GetShapeF1D", (PyObject *)&GetShapeF1D_Type);
}
PyObject *_wrap_UnaryFunction1DVectorViewShape___call__(PyObject *self , PyObject *args) {
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DVectorViewShape___init__(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVectorViewShape___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_vectorviewshape = new UnaryFunction1D< std::vector<ViewShape*> >();
else {
self->uf1D_vectorviewshape = new UnaryFunction1D< std::vector<ViewShape*> >( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DVectorViewShape___dealloc__(BPy_UnaryFunction1DVectorViewShape* self)
{
delete self->uf1D_vectorviewshape;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction1DVectorViewShape_setIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVectorViewShape___repr__(BPy_UnaryFunction1DVectorViewShape* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_vectorviewshape->getName().c_str(), self->uf1D_vectorviewshape );
}
PyObject *_wrap_UnaryFunction1DVectorViewShape_getIntegrationType(PyObject *self , PyObject *args) {
PyObject * UnaryFunction1DVectorViewShape_getName( BPy_UnaryFunction1DVectorViewShape *self )
{
return PyString_FromString( self->uf1D_vectorviewshape->getName().c_str() );
}
PyObject * UnaryFunction1DVectorViewShape___call__( BPy_UnaryFunction1DVectorViewShape *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVectorViewShape___call__ " << endl;
return NULL;
}
std::vector<ViewShape*> vs( self->uf1D_vectorviewshape->operator()(*( ((BPy_Interface1D *) obj)->if1D )) );
PyObject *list = PyList_New(NULL);
for( unsigned int i = 0; i < vs.size(); i++)
PyList_Append(list, BPy_ViewShape_from_ViewShape(*( vs[i] )) );
return list;
}
PyObject * UnaryFunction1DVectorViewShape_setIntegrationType(BPy_UnaryFunction1DVectorViewShape* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVectorViewShape_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_vectorviewshape->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DVectorViewShape_getIntegrationType(BPy_UnaryFunction1DVectorViewShape* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_vectorviewshape->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

37
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H
#include "../BPy_UnaryFunction1D.h"
#include <vector>
#include "../../view_map/ViewMap.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DVectorViewShape_Type;
#define BPy_UnaryFunction1DVectorViewShape_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DVectorViewShape_Type)
/*---------------------------Python BPy_UnaryFunction1DVectorViewShape structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D< std::vector<ViewShape*> > *uf1D_vectorviewshape;
} BPy_UnaryFunction1DVectorViewShape;
/*---------------------------Python BPy_UnaryFunction1DVectorViewShape visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DVectorViewShape_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVECTORVIEWSHAPE_H */

224
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp Normal file
View File

@@ -0,0 +1,224 @@
#include "BPy_UnaryFunction1DVoid.h"
#include "../BPy_Convert.h"
#include "../BPy_Interface1D.h"
#include "../BPy_IntegrationType.h"
#include "UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h"
#include "UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h"
#include "UnaryFunction1D_void/BPy_TimeStampF1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction1DVoid instance -----------*/
static int UnaryFunction1DVoid___init__(BPy_UnaryFunction1DVoid* self, PyObject *args);
static void UnaryFunction1DVoid___dealloc__(BPy_UnaryFunction1DVoid* self);
static PyObject * UnaryFunction1DVoid___repr__(BPy_UnaryFunction1DVoid* self);
static PyObject * UnaryFunction1DVoid_getName( BPy_UnaryFunction1DVoid *self);
static PyObject * UnaryFunction1DVoid___call__( BPy_UnaryFunction1DVoid *self, PyObject *args);
static PyObject * UnaryFunction1DVoid_setIntegrationType(BPy_UnaryFunction1DVoid* self, PyObject *args);
static PyObject * UnaryFunction1DVoid_getIntegrationType(BPy_UnaryFunction1DVoid* self);
/*----------------------UnaryFunction1DVoid instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction1DVoid_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction1DVoid_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 1D function."},
{"__call__", ( PyCFunction ) UnaryFunction1DVoid___call__, METH_VARARGS, "（Interface1D if1D ）Builds a UnaryFunction1D from an integration type. " },
{"setIntegrationType", ( PyCFunction ) UnaryFunction1DVoid_setIntegrationType, METH_VARARGS, "（IntegrationType i ）Sets the integration method" },
{"getIntegrationType", ( PyCFunction ) UnaryFunction1DVoid_getIntegrationType, METH_NOARGS, "() Returns the integration method." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction1DVoid type definition ------------------------------*/
PyTypeObject UnaryFunction1DVoid_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction1DVoid", /* tp_name */
sizeof( BPy_UnaryFunction1DVoid ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction1DVoid___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction1DVoid___repr__, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_UnaryFunction1DVoid_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction1DVoid___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//-------------------MODULE INITIALIZATION--------------------------------
PyMODINIT_FUNC UnaryFunction1DVoid_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction1DVoid_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction1DVoid_Type );
PyModule_AddObject(module, "UnaryFunction1DVoid", (PyObject *)&UnaryFunction1DVoid_Type);
if( PyType_Ready( &ChainingTimeStampF1D_Type ) < 0 )
return;
Py_INCREF( &ChainingTimeStampF1D_Type );
PyModule_AddObject(module, "ChainingTimeStampF1D", (PyObject *)&ChainingTimeStampF1D_Type);
if( PyType_Ready( &IncrementChainingTimeStampF1D_Type ) < 0 )
return;
Py_INCREF( &IncrementChainingTimeStampF1D_Type );
PyModule_AddObject(module, "IncrementChainingTimeStampF1D", (PyObject *)&IncrementChainingTimeStampF1D_Type);
if( PyType_Ready( &TimeStampF1D_Type ) < 0 )
return;
Py_INCREF( &TimeStampF1D_Type );
PyModule_AddObject(module, "TimeStampF1D", (PyObject *)&TimeStampF1D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction1DVoid___init__(BPy_UnaryFunction1DVoid* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "|O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVoid___init__ " << endl;
return -1;
}
if( !obj )
self->uf1D_void = new UnaryFunction1D<void>();
else {
self->uf1D_void = new UnaryFunction1D<void>( IntegrationType_from_BPy_IntegrationType(obj) );
}
return 0;
}
void UnaryFunction1DVoid___dealloc__(BPy_UnaryFunction1DVoid* self)
{
delete self->uf1D_void;
UnaryFunction1D_Type.tp_dealloc((PyObject*)self);
}
PyObject * UnaryFunction1DVoid___repr__(BPy_UnaryFunction1DVoid* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf1D_void->getName().c_str(), self->uf1D_void );
}
PyObject * UnaryFunction1DVoid_getName( BPy_UnaryFunction1DVoid *self )
{
return PyString_FromString( self->uf1D_void->getName().c_str() );
}
PyObject * UnaryFunction1DVoid___call__( BPy_UnaryFunction1DVoid *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface1D_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVoid___call__ " << endl;
return NULL;
}
self->uf1D_void->operator()(*( ((BPy_Interface1D *) obj)->if1D ));
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DVoid_setIntegrationType(BPy_UnaryFunction1DVoid* self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_IntegrationType_Check(obj) ) {
cout << "ERROR: UnaryFunction1DVoid_setIntegrationType " << endl;
Py_RETURN_NONE;
}
self->uf1D_void->setIntegrationType( IntegrationType_from_BPy_IntegrationType(obj) );
Py_RETURN_NONE;
}
PyObject * UnaryFunction1DVoid_getIntegrationType(BPy_UnaryFunction1DVoid* self) {
return BPy_IntegrationType_from_IntegrationType( self->uf1D_void->getIntegrationType() );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

34
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H
#define FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H
#include "../BPy_UnaryFunction1D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction1DVoid_Type;
#define BPy_UnaryFunction1DVoid_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction1DVoid_Type)
/*---------------------------Python BPy_UnaryFunction1DVoid structure definition----------*/
typedef struct {
BPy_UnaryFunction1D py_uf1D;
UnaryFunction1D<void> *uf1D_void;
} BPy_UnaryFunction1DVoid;
/*---------------------------Python BPy_UnaryFunction1DVoid visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction1DVoid_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1DVOID_H */

127
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp
View File

@@ -1,12 +1,123 @@
PyObject *_wrap_CurveNatureF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_CurveNatureF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for CurveNatureF1D instance -----------*/
static int CurveNatureF1D___init__( BPy_CurveNatureF1D* self, PyObject *args);
/*-----------------------BPy_CurveNatureF1D type definition ------------------------------*/
PyTypeObject CurveNatureF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"CurveNatureF1D", /* tp_name */
sizeof( BPy_CurveNatureF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DEdgeNature_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)CurveNatureF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int CurveNatureF1D___init__( BPy_CurveNatureF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: CurveNatureF1D___init__" << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_edgenature.uf1D_edgenature = new Functions1D::CurveNatureF1D(t);
return 0;
}
PyObject *_wrap_CurveNatureF1D___call__(PyObject *self , PyObject *args) {
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
PyObject *_wrap_delete_CurveNatureF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_CURVENATUREF1D_H
#define FREESTYLE_PYTHON_CURVENATUREF1D_H
#include "../BPy_UnaryFunction1DEdgeNature.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject CurveNatureF1D_Type;
#define BPy_CurveNatureF1D_Check(v) (( (PyObject *) v)->ob_type == &CurveNatureF1D_Type)
/*---------------------------Python BPy_CurveNatureF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DEdgeNature py_uf1D_edgenature;
} BPy_CurveNatureF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_CURVENATUREF1D_H */

126
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp
View File

@@ -1,12 +1,122 @@
PyObject *_wrap_Normal2DF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_Normal2DF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for Normal2DF1D instance -----------*/
static int Normal2DF1D___init__( BPy_Normal2DF1D* self, PyObject *args);
/*-----------------------BPy_Normal2DF1D type definition ------------------------------*/
PyTypeObject Normal2DF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"Normal2DF1D", /* tp_name */
sizeof( BPy_Normal2DF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVec2f_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)Normal2DF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int Normal2DF1D___init__( BPy_Normal2DF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: Normal2DF1D___init__" << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Normal2DF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_Normal2DF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_Normal2DF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_NORMAL2DF1D_H
#define FREESTYLE_PYTHON_NORMAL2DF1D_H
#include "../BPy_UnaryFunction1DVec2f.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject Normal2DF1D_Type;
#define BPy_Normal2DF1D_Check(v) (( (PyObject *) v)->ob_type == &Normal2DF1D_Type)
/*---------------------------Python BPy_Normal2DF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVec2f py_uf1D_vec2f;
} BPy_Normal2DF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_NORMAL2DF1D_H */

127
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp
View File

@@ -1,12 +1,123 @@
PyObject *_wrap_Orientation2DF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_Orientation2DF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for Orientation2DF1D instance -----------*/
static int Orientation2DF1D___init__( BPy_Orientation2DF1D* self, PyObject *args);
/*-----------------------BPy_Orientation2DF1D type definition ------------------------------*/
PyTypeObject Orientation2DF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"Orientation2DF1D", /* tp_name */
sizeof( BPy_Orientation2DF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVec2f_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)Orientation2DF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int Orientation2DF1D___init__( BPy_Orientation2DF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: Orientation2DF1D___init__" << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_vec2f.uf1D_vec2f = new Functions1D::Orientation2DF1D(t);
return 0;
}
PyObject *_wrap_Orientation2DF1D___call__(PyObject *self , PyObject *args) {
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
PyObject *_wrap_delete_Orientation2DF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_ORIENTATION2DF1D_H
#define FREESTYLE_PYTHON_ORIENTATION2DF1D_H
#include "../BPy_UnaryFunction1DVec2f.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject Orientation2DF1D_Type;
#define BPy_Orientation2DF1D_Check(v) (( (PyObject *) v)->ob_type == &Orientation2DF1D_Type)
/*---------------------------Python BPy_Orientation2DF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVec2f py_uf1D_vec2f;
} BPy_Orientation2DF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_ORIENTATION2DF1D_H */

128
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp
View File

@@ -1,12 +1,124 @@
PyObject *_wrap_Orientation3DF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_Orientation3DF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for Orientation3DF1D instance -----------*/
static int Orientation3DF1D___init__( BPy_Orientation3DF1D* self, PyObject *args);
/*-----------------------BPy_Orientation3DF1D type definition ------------------------------*/
PyTypeObject Orientation3DF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"Orientation3DF1D", /* tp_name */
sizeof( BPy_Orientation3DF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVec3f_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)Orientation3DF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int Orientation3DF1D___init__( BPy_Orientation3DF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: Orientation3DF1D___init__" << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_vec3f.uf1D_vec3f = new Functions1D::Orientation3DF1D(t);
return 0;
}
PyObject *_wrap_Orientation3DF1D___call__(PyObject *self , PyObject *args) {
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
PyObject *_wrap_delete_Orientation3DF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_ORIENTATION3DF1D_H
#define FREESTYLE_PYTHON_ORIENTATION3DF1D_H
#include "../BPy_UnaryFunction1DVec3f.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject Orientation3DF1D_Type;
#define BPy_Orientation3DF1D_Check(v) (( (PyObject *) v)->ob_type == &Orientation3DF1D_Type)
/*---------------------------Python BPy_Orientation3DF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVec3f py_uf1D_vec3f;
} BPy_Orientation3DF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_ORIENTATION3DF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp Normal file
View File

@@ -0,0 +1,121 @@
#include "BPy_Curvature2DAngleF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for Curvature2DAngleF1D instance -----------*/
static int Curvature2DAngleF1D___init__(BPy_Curvature2DAngleF1D* self, PyObject *args);
/*-----------------------BPy_Curvature2DAngleF1D type definition ------------------------------*/
PyTypeObject Curvature2DAngleF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"Curvature2DAngleF1D", /* tp_name */
sizeof( BPy_Curvature2DAngleF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)Curvature2DAngleF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int Curvature2DAngleF1D___init__( BPy_Curvature2DAngleF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: Curvature2DAngleF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::Curvature2DAngleF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H
#define FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject Curvature2DAngleF1D_Type;
#define BPy_Curvature2DAngleF1D_Check(v) (( (PyObject *) v)->ob_type == &Curvature2DAngleF1D_Type)
/*---------------------------Python BPy_Curvature2DAngleF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_Curvature2DAngleF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_CURVATURE2DANGLEF1D_H */

124
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp
View File

@@ -1,8 +1,124 @@
PyObject *_wrap_DensityF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_DensityF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for DensityF1D instance -----------*/
static int DensityF1D___init__(BPy_DensityF1D* self, PyObject *args);
/*-----------------------BPy_DensityF1D type definition ------------------------------*/
PyTypeObject DensityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"DensityF1D", /* tp_name */
sizeof( BPy_DensityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)DensityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int DensityF1D___init__( BPy_DensityF1D* self, PyObject *args)
{
PyObject *obj = 0;
double d = 2.0;
float f = 2.0;
if( !PyArg_ParseTuple(args, "|dOf", &d, &obj, &f) ) {
cout << "ERROR: DensityF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::DensityF1D(d,t,f);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_DensityF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_DENSITYF1D_H
#define FREESTYLE_PYTHON_DENSITYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject DensityF1D_Type;
#define BPy_DensityF1D_Check(v) (( (PyObject *) v)->ob_type == &DensityF1D_Type)
/*---------------------------Python BPy_DensityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_DensityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_DENSITYF1D_H */

128
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp
View File

@@ -1,12 +1,124 @@
PyObject *_wrap_GetCompleteViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_GetCompleteViewMapDensityF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetCompleteViewMapDensityF1D instance -----------*/
static int GetCompleteViewMapDensityF1D___init__(BPy_GetCompleteViewMapDensityF1D* self, PyObject *args);
/*-----------------------BPy_GetCompleteViewMapDensityF1D type definition ------------------------------*/
PyTypeObject GetCompleteViewMapDensityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetCompleteViewMapDensityF1D", /* tp_name */
sizeof( BPy_GetCompleteViewMapDensityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetCompleteViewMapDensityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetCompleteViewMapDensityF1D___init__( BPy_GetCompleteViewMapDensityF1D* self, PyObject *args)
{
PyObject *obj = 0;
unsigned i;
float f = 2.0;
if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
cout << "ERROR: GetCompleteViewMapDensityF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetCompleteViewMapDensityF1D(i,t,f);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_GetCompleteViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_GetCompleteViewMapDensityF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H
#define FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetCompleteViewMapDensityF1D_Type;
#define BPy_GetCompleteViewMapDensityF1D_Check(v) (( (PyObject *) v)->ob_type == &GetCompleteViewMapDensityF1D_Type)
/*---------------------------Python BPy_GetCompleteViewMapDensityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetCompleteViewMapDensityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETCOMPLETEVIEWMAPDENSITYF1D_H */

128
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp
View File

@@ -1,12 +1,124 @@
PyObject *_wrap_GetDirectionalViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_GetDirectionalViewMapDensityF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetDirectionalViewMapDensityF1D instance -----------*/
static int GetDirectionalViewMapDensityF1D___init__(BPy_GetDirectionalViewMapDensityF1D* self, PyObject *args);
/*-----------------------BPy_GetDirectionalViewMapDensityF1D type definition ------------------------------*/
PyTypeObject GetDirectionalViewMapDensityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetDirectionalViewMapDensityF1D", /* tp_name */
sizeof( BPy_GetDirectionalViewMapDensityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetDirectionalViewMapDensityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetDirectionalViewMapDensityF1D___init__( BPy_GetDirectionalViewMapDensityF1D* self, PyObject *args)
{
PyObject *obj = 0;
unsigned int u1, u2;
float f = 2.0;
if( !PyArg_ParseTuple(args, "II|Of", &u1, &u2, &obj, &f) ) {
cout << "ERROR: GetDirectionalViewMapDensityF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetDirectionalViewMapDensityF1D(u1, u2, t, f);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_GetDirectionalViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_GetDirectionalViewMapDensityF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H
#define FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetDirectionalViewMapDensityF1D_Type;
#define BPy_GetDirectionalViewMapDensityF1D_Check(v) (( (PyObject *) v)->ob_type == &GetDirectionalViewMapDensityF1D_Type)
/*---------------------------Python BPy_GetDirectionalViewMapDensityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetDirectionalViewMapDensityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETDIRECTIONALVIEWMAPDENSITYF1D_H */

122
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp Normal file
View File

@@ -0,0 +1,122 @@
#include "BPy_GetProjectedXF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetProjectedXF1D instance -----------*/
static int GetProjectedXF1D___init__(BPy_GetProjectedXF1D* self, PyObject *args );
/*-----------------------BPy_GetProjectedXF1D type definition ------------------------------*/
PyTypeObject GetProjectedXF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetProjectedXF1D", /* tp_name */
sizeof( BPy_GetProjectedXF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetProjectedXF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetProjectedXF1D___init__( BPy_GetProjectedXF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetProjectedXF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedXF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETPROJECTEDXF1D_H
#define FREESTYLE_PYTHON_GETPROJECTEDXF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetProjectedXF1D_Type;
#define BPy_GetProjectedXF1D_Check(v) (( (PyObject *) v)->ob_type == &GetProjectedXF1D_Type)
/*---------------------------Python BPy_GetProjectedXF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetProjectedXF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETPROJECTEDXF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp Normal file
View File

@@ -0,0 +1,121 @@
#include "BPy_GetProjectedYF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetProjectedYF1D instance -----------*/
static int GetProjectedYF1D___init__(BPy_GetProjectedYF1D* self, PyObject *args );
/*-----------------------BPy_GetProjectedYF1D type definition ------------------------------*/
PyTypeObject GetProjectedYF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetProjectedYF1D", /* tp_name */
sizeof( BPy_GetProjectedYF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetProjectedYF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetProjectedYF1D___init__( BPy_GetProjectedYF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetProjectedYF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedYF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETPROJECTEDYF1D_H
#define FREESTYLE_PYTHON_GETPROJECTEDYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetProjectedYF1D_Type;
#define BPy_GetProjectedYF1D_Check(v) (( (PyObject *) v)->ob_type == &GetProjectedYF1D_Type)
/*---------------------------Python BPy_GetProjectedYF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetProjectedYF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETPROJECTEDYF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp Normal file
View File

@@ -0,0 +1,121 @@
#include "BPy_GetProjectedZF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetProjectedZF1D instance -----------*/
static int GetProjectedZF1D___init__(BPy_GetProjectedZF1D* self, PyObject *args );
/*-----------------------BPy_GetProjectedZF1D type definition ------------------------------*/
PyTypeObject GetProjectedZF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetProjectedZF1D", /* tp_name */
sizeof( BPy_GetProjectedZF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetProjectedZF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetProjectedZF1D___init__( BPy_GetProjectedZF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetProjectedZF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetProjectedZF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETPROJECTEDZF1D_H
#define FREESTYLE_PYTHON_GETPROJECTEDZF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetProjectedZF1D_Type;
#define BPy_GetProjectedZF1D_Check(v) (( (PyObject *) v)->ob_type == &GetProjectedZF1D_Type)
/*---------------------------Python BPy_GetProjectedZF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetProjectedZF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETPROJECTEDZF1D_H */

124
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp Normal file
View File

@@ -0,0 +1,124 @@
#include "BPy_GetSteerableViewMapDensityF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetSteerableViewMapDensityF1D instance -----------*/
static int GetSteerableViewMapDensityF1D___init__(BPy_GetSteerableViewMapDensityF1D* self, PyObject *args);
/*-----------------------BPy_GetSteerableViewMapDensityF1D type definition ------------------------------*/
PyTypeObject GetSteerableViewMapDensityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetSteerableViewMapDensityF1D", /* tp_name */
sizeof( BPy_GetSteerableViewMapDensityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetSteerableViewMapDensityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetSteerableViewMapDensityF1D___init__( BPy_GetSteerableViewMapDensityF1D* self, PyObject *args)
{
PyObject *obj = 0;
int i;
float f = 2.0;
if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
cout << "ERROR: GetSteerableViewMapDensityF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetSteerableViewMapDensityF1D(i,t,f);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H
#define FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetSteerableViewMapDensityF1D_Type;
#define BPy_GetSteerableViewMapDensityF1D_Check(v) (( (PyObject *) v)->ob_type == &GetSteerableViewMapDensityF1D_Type)
/*---------------------------Python BPy_GetSteerableViewMapDensityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetSteerableViewMapDensityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETSTEERABLEVIEWMAPDENSITYF1D_H */

124
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp Normal file
View File

@@ -0,0 +1,124 @@
#include "BPy_GetViewMapGradientNormF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetViewMapGradientNormF1D instance -----------*/
static int GetViewMapGradientNormF1D___init__(BPy_GetViewMapGradientNormF1D* self, PyObject *args);
/*-----------------------BPy_GetViewMapGradientNormF1D type definition ------------------------------*/
PyTypeObject GetViewMapGradientNormF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetViewMapGradientNormF1D", /* tp_name */
sizeof( BPy_GetViewMapGradientNormF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetViewMapGradientNormF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetViewMapGradientNormF1D___init__( BPy_GetViewMapGradientNormF1D* self, PyObject *args)
{
PyObject *obj = 0;
int i;
float f = 2.0;
if( !PyArg_ParseTuple(args, "i|Of", &i, &obj, &f) ) {
cout << "ERROR: GetViewMapGradientNormF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetViewMapGradientNormF1D(i,t,f);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H
#define FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetViewMapGradientNormF1D_Type;
#define BPy_GetViewMapGradientNormF1D_Check(v) (( (PyObject *) v)->ob_type == &GetViewMapGradientNormF1D_Type)
/*---------------------------Python BPy_GetViewMapGradientNormF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetViewMapGradientNormF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETVIEWMAPGRADIENTNORMF1D_H */

122
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp Normal file
View File

@@ -0,0 +1,122 @@
#include "BPy_GetXF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetXF1D instance -----------*/
static int GetXF1D___init__(BPy_GetXF1D* self, PyObject *args );
/*-----------------------BPy_GetXF1D type definition ------------------------------*/
PyTypeObject GetXF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetXF1D", /* tp_name */
sizeof( BPy_GetXF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetXF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetXF1D___init__( BPy_GetXF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetXF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetXF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETXF1D_H
#define FREESTYLE_PYTHON_GETXF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetXF1D_Type;
#define BPy_GetXF1D_Check(v) (( (PyObject *) v)->ob_type == &GetXF1D_Type)
/*---------------------------Python BPy_GetXF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetXF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETXF1D_H */

120
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp Normal file
View File

@@ -0,0 +1,120 @@
#include "BPy_GetYF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetYF1D instance -----------*/
static int GetYF1D___init__(BPy_GetYF1D* self, PyObject *args );
/*-----------------------BPy_GetYF1D type definition ------------------------------*/
PyTypeObject GetYF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetYF1D", /* tp_name */
sizeof( BPy_GetYF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetYF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetYF1D___init__( BPy_GetYF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetYF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetYF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETYF1D_H
#define FREESTYLE_PYTHON_GETYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetYF1D_Type;
#define BPy_GetYF1D_Check(v) (( (PyObject *) v)->ob_type == &GetYF1D_Type)
/*---------------------------Python BPy_GetYF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetYF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETYF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp Normal file
View File

@@ -0,0 +1,121 @@
#include "BPy_GetZF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetZF1D instance -----------*/
static int GetZF1D___init__(BPy_GetZF1D* self, PyObject *args );
/*-----------------------BPy_GetZF1D type definition ------------------------------*/
PyTypeObject GetZF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetZF1D", /* tp_name */
sizeof( BPy_GetZF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetZF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetZF1D___init__( BPy_GetZF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: GetZF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::GetZF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETZF1D_H
#define FREESTYLE_PYTHON_GETZF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetZF1D_Type;
#define BPy_GetZF1D_Check(v) (( (PyObject *) v)->ob_type == &GetZF1D_Type)
/*---------------------------Python BPy_GetZF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_GetZF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETZF1D_H */

127
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp
View File

@@ -1,12 +1,121 @@
PyObject *_wrap_LocalAverageDepthF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_LocalAverageDepthF1D.h"
#include "../../../stroke/AdvancedFunctions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for LocalAverageDepthF1D instance -----------*/
static int LocalAverageDepthF1D___init__(BPy_LocalAverageDepthF1D* self, PyObject *args);
/*-----------------------BPy_LocalAverageDepthF1D type definition ------------------------------*/
PyTypeObject LocalAverageDepthF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"LocalAverageDepthF1D", /* tp_name */
sizeof( BPy_LocalAverageDepthF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)LocalAverageDepthF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int LocalAverageDepthF1D___init__( BPy_LocalAverageDepthF1D* self, PyObject *args)
{
PyObject *obj = 0;
double d;
if( !PyArg_ParseTuple(args, "d|O", &d, &obj) ) {
cout << "ERROR: LocalAverageDepthF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::LocalAverageDepthF1D(d,t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_LocalAverageDepthF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_LocalAverageDepthF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H
#define FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject LocalAverageDepthF1D_Type;
#define BPy_LocalAverageDepthF1D_Check(v) (( (PyObject *) v)->ob_type == &LocalAverageDepthF1D_Type)
/*---------------------------Python BPy_LocalAverageDepthF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_LocalAverageDepthF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF1D_H */

122
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp Normal file
View File

@@ -0,0 +1,122 @@
#include "BPy_ZDiscontinuityF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for ZDiscontinuityF1D instance -----------*/
static int ZDiscontinuityF1D___init__(BPy_ZDiscontinuityF1D* self, PyObject *args );
/*-----------------------BPy_ZDiscontinuityF1D type definition ------------------------------*/
PyTypeObject ZDiscontinuityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"ZDiscontinuityF1D", /* tp_name */
sizeof( BPy_ZDiscontinuityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)ZDiscontinuityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int ZDiscontinuityF1D___init__( BPy_ZDiscontinuityF1D* self, PyObject *args )
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: ZDiscontinuityF1D___init__ " << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_double.uf1D_double = new Functions1D::ZDiscontinuityF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H
#define FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H
#include "../BPy_UnaryFunction1DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject ZDiscontinuityF1D_Type;
#define BPy_ZDiscontinuityF1D_Check(v) (( (PyObject *) v)->ob_type == &ZDiscontinuityF1D_Type)
/*---------------------------Python BPy_ZDiscontinuityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DDouble py_uf1D_double;
} BPy_ZDiscontinuityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_ZDISCONTINUITYF1D_H */

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_Curvature2DAngleF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_Curvature2DAngleF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_Curvature2DAngleF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_Curvature2DAngleF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedXF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetProjectedXF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetProjectedXF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetProjectedXF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedYF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetProjectedYF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetProjectedYF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetProjectedYF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetProjectedZF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetProjectedZF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetProjectedZF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetProjectedZF1D(PyObject *self , PyObject *args) {
}

8
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetSteerableViewMapDensityF1D.cpp
View File

@@ -1,8 +0,0 @@
PyObject *_wrap_GetSteerableViewMapDensityF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetSteerableViewMapDensityF1D___call__(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetViewMapGradientNormF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetViewMapGradientNormF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetViewMapGradientNormF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetViewMapGradientNormF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetXF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetXF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetXF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetXF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetYF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetYF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetYF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetYF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_GetZF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_GetZF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_GetZF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_GetZF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_real/BPy_ZDiscontinuityF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_ZDiscontinuityF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_ZDiscontinuityF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_ZDiscontinuityF1D(PyObject *self , PyObject *args) {
}

12
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned/BPy_QuantitativeInvisibilityF1D.cpp
View File

@@ -1,12 +0,0 @@
PyObject *_wrap_QuantitativeInvisibilityF1D_getName(PyObject *self , PyObject *args) {
}
PyObject *_wrap_QuantitativeInvisibilityF1D___call__(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_QuantitativeInvisibilityF1D(PyObject *self , PyObject *args) {
}

122
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp Normal file
View File

@@ -0,0 +1,122 @@
#include "BPy_QuantitativeInvisibilityF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for QuantitativeInvisibilityF1D instance -----------*/
static int QuantitativeInvisibilityF1D___init__(BPy_QuantitativeInvisibilityF1D* self, PyObject *args);
/*-----------------------BPy_QuantitativeInvisibilityF1D type definition ------------------------------*/
PyTypeObject QuantitativeInvisibilityF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"QuantitativeInvisibilityF1D", /* tp_name */
sizeof( BPy_QuantitativeInvisibilityF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DUnsigned_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)QuantitativeInvisibilityF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int QuantitativeInvisibilityF1D___init__( BPy_QuantitativeInvisibilityF1D* self, PyObject *args)
{
PyObject *obj = 0;
if( !PyArg_ParseTuple(args, "|O", &obj) ) {
cout << "ERROR: QuantitativeInvisibilityF1D___init__" << endl;
return -1;
}
IntegrationType t = ( obj && BPy_IntegrationType_Check(obj) ) ? IntegrationType_from_BPy_IntegrationType(obj) : MEAN;
self->py_uf1D_unsigned.uf1D_unsigned = new Functions1D::QuantitativeInvisibilityF1D(t);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H
#define FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H
#include "../BPy_UnaryFunction1DUnsigned.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject QuantitativeInvisibilityF1D_Type;
#define BPy_QuantitativeInvisibilityF1D_Check(v) (( (PyObject *) v)->ob_type == &QuantitativeInvisibilityF1D_Type)
/*---------------------------Python BPy_QuantitativeInvisibilityF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DUnsigned py_uf1D_unsigned;
} BPy_QuantitativeInvisibilityF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_QUANTITATIVEINVISIBILITYF1D_H */

117
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp
View File

@@ -1,12 +1,113 @@
PyObject *_wrap_GetOccludeeF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_GetOccludeeF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetOccludeeF1D instance -----------*/
static int GetOccludeeF1D___init__(BPy_GetOccludeeF1D* self);
/*-----------------------BPy_GetOccludeeF1D type definition ------------------------------*/
PyTypeObject GetOccludeeF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetOccludeeF1D", /* tp_name */
sizeof( BPy_GetOccludeeF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVectorViewShape_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetOccludeeF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetOccludeeF1D___init__( BPy_GetOccludeeF1D* self )
{
self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetOccludeeF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_GetOccludeeF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_GetOccludeeF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETOCCLUDEEF1D_H
#define FREESTYLE_PYTHON_GETOCCLUDEEF1D_H
#include "../BPy_UnaryFunction1DVectorViewShape.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetOccludeeF1D_Type;
#define BPy_GetOccludeeF1D_Check(v) (( (PyObject *) v)->ob_type == &GetOccludeeF1D_Type)
/*---------------------------Python BPy_GetOccludeeF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
} BPy_GetOccludeeF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETOCCLUDEEF1D_H */

117
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp
View File

@@ -1,12 +1,113 @@
PyObject *_wrap_GetOccludersF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_GetOccludersF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetOccludersF1D instance -----------*/
static int GetOccludersF1D___init__(BPy_GetOccludersF1D* self);
/*-----------------------BPy_GetOccludersF1D type definition ------------------------------*/
PyTypeObject GetOccludersF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetOccludersF1D", /* tp_name */
sizeof( BPy_GetOccludersF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVectorViewShape_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetOccludersF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetOccludersF1D___init__( BPy_GetOccludersF1D* self )
{
self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetOccludersF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_GetOccludersF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_GetOccludersF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETOCCLUDERSF1D_H
#define FREESTYLE_PYTHON_GETOCCLUDERSF1D_H
#include "../BPy_UnaryFunction1DVectorViewShape.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetOccludersF1D_Type;
#define BPy_GetOccludersF1D_Check(v) (( (PyObject *) v)->ob_type == &GetOccludersF1D_Type)
/*---------------------------Python BPy_GetOccludersF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
} BPy_GetOccludersF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETOCCLUDERSF1D_H */

117
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp
View File

@@ -1,12 +1,113 @@
PyObject *_wrap_GetShapeF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_GetShapeF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for GetShapeF1D instance -----------*/
static int GetShapeF1D___init__(BPy_GetShapeF1D* self);
/*-----------------------BPy_GetShapeF1D type definition ------------------------------*/
PyTypeObject GetShapeF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"GetShapeF1D", /* tp_name */
sizeof( BPy_GetShapeF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVectorViewShape_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)GetShapeF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int GetShapeF1D___init__( BPy_GetShapeF1D* self )
{
self->py_uf1D_vectorviewshape.uf1D_vectorviewshape = new Functions1D::GetShapeF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_GetShapeF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_GetShapeF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_GETSHAPEF1D_H
#define FREESTYLE_PYTHON_GETSHAPEF1D_H
#include "../BPy_UnaryFunction1DVectorViewShape.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject GetShapeF1D_Type;
#define BPy_GetShapeF1D_Check(v) (( (PyObject *) v)->ob_type == &GetShapeF1D_Type)
/*---------------------------Python BPy_GetShapeF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVectorViewShape py_uf1D_vectorviewshape;
} BPy_GetShapeF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_GETSHAPEF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp
View File

@@ -1,16 +1,113 @@
PyObject *_wrap_ChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_ChainingTimeStampF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for ChainingTimeStampF1D instance -----------*/
static int ChainingTimeStampF1D___init__(BPy_ChainingTimeStampF1D* self);
/*-----------------------BPy_ChainingTimeStampF1D type definition ------------------------------*/
PyTypeObject ChainingTimeStampF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"ChainingTimeStampF1D", /* tp_name */
sizeof( BPy_ChainingTimeStampF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVoid_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)ChainingTimeStampF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int ChainingTimeStampF1D___init__( BPy_ChainingTimeStampF1D* self )
{
self->py_uf1D_void.uf1D_void = new Functions1D::ChainingTimeStampF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_ChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_new_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_ChainingTimeStampF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H
#define FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H
#include "../BPy_UnaryFunction1DVoid.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject ChainingTimeStampF1D_Type;
#define BPy_ChainingTimeStampF1D_Check(v) (( (PyObject *) v)->ob_type == &ChainingTimeStampF1D_Type)
/*---------------------------Python BPy_ChainingTimeStampF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVoid py_uf1D_void;
} BPy_ChainingTimeStampF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp
View File

@@ -1,16 +1,113 @@
PyObject *_wrap_IncrementChainingTimeStampF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_IncrementChainingTimeStampF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for IncrementChainingTimeStampF1D instance -----------*/
static int IncrementChainingTimeStampF1D___init__(BPy_IncrementChainingTimeStampF1D* self);
/*-----------------------BPy_IncrementChainingTimeStampF1D type definition ------------------------------*/
PyTypeObject IncrementChainingTimeStampF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"IncrementChainingTimeStampF1D", /* tp_name */
sizeof( BPy_IncrementChainingTimeStampF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVoid_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)IncrementChainingTimeStampF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int IncrementChainingTimeStampF1D___init__( BPy_IncrementChainingTimeStampF1D* self )
{
self->py_uf1D_void.uf1D_void = new Functions1D::IncrementChainingTimeStampF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_IncrementChainingTimeStampF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_new_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_IncrementChainingTimeStampF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H
#define FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H
#include "../BPy_UnaryFunction1DVoid.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject IncrementChainingTimeStampF1D_Type;
#define BPy_IncrementChainingTimeStampF1D_Check(v) (( (PyObject *) v)->ob_type == &IncrementChainingTimeStampF1D_Type)
/*---------------------------Python BPy_IncrementChainingTimeStampF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVoid py_uf1D_void;
} BPy_IncrementChainingTimeStampF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_INCREMENTCHAININGTIMESTAMPF1D_H */

121
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp
View File

@@ -1,16 +1,113 @@
PyObject *_wrap_TimeStampF1D_getName(PyObject *self , PyObject *args) {
#include "BPy_TimeStampF1D.h"
#include "../../../view_map/Functions1D.h"
#include "../../BPy_Convert.h"
#include "../../BPy_IntegrationType.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for TimeStampF1D instance -----------*/
static int TimeStampF1D___init__(BPy_TimeStampF1D* self);
/*-----------------------BPy_TimeStampF1D type definition ------------------------------*/
PyTypeObject TimeStampF1D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"TimeStampF1D", /* tp_name */
sizeof( BPy_TimeStampF1D ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
NULL, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
NULL, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
NULL, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
NULL, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction1DVoid_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)TimeStampF1D___init__, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
//------------------------INSTANCE METHODS ----------------------------------
int TimeStampF1D___init__( BPy_TimeStampF1D* self )
{
self->py_uf1D_void.uf1D_void = new Functions1D::TimeStampF1D();
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_TimeStampF1D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_new_TimeStampF1D(PyObject *self , PyObject *args) {
}
PyObject *_wrap_delete_TimeStampF1D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_TIMESTAMPF1D_H
#define FREESTYLE_PYTHON_TIMESTAMPF1D_H
#include "../BPy_UnaryFunction1DVoid.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject TimeStampF1D_Type;
#define BPy_TimeStampF1D_Check(v) (( (PyObject *) v)->ob_type == &TimeStampF1D_Type)
/*---------------------------Python BPy_TimeStampF1D structure definition----------*/
typedef struct {
BPy_UnaryFunction1DVoid py_uf1D_void;
} BPy_TimeStampF1D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_CHAININGTIMESTAMPF1D_H */