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

soc-2008-mxcurioni: implemented and tested unary predicates. The good news is that My approach seems to works (even though it is not fully testable as it needs Freestyle to be running). I will now port the 80 predicate subclasses left.

Browse Source 
In this commit, UnaryPredicate0DDouble and its subclasses DensityF0D and LocalAverageDepthF0D are implemented and integrated in the API.
This commit is contained in:
Maxime Curioni
2008-07-27 03:40:37 +00:00
parent 0c64c49d2f
commit 995fdd9fcd
8 changed files with 501 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
source/blender/freestyle/intern/python/BPy_UnaryFunction0D.cpp
View File

@@ -1,6 +1,6 @@
#include "BPy_UnaryFunction0D.h"
#include "BPy_Convert.h"
#include "UnaryFunction0D/BPy_UnaryFunction0DDouble.h"
#ifdef __cplusplus
extern "C" {
@@ -9,17 +9,11 @@ extern "C" {
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction0D instance -----------*/
static int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds);
static void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D *self);
static PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D *self);
static PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args);
static PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args);
/*----------------------UnaryFunction0D instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction0D_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction0D_getName, METH_NOARGS, ""},
{"__call__", ( PyCFunction ) UnaryFunction0D___call__, METH_VARARGS, "" },
{NULL, NULL, 0, NULL}
};
@@ -89,7 +83,7 @@ PyTypeObject UnaryFunction0D_Type = {
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction0D___init__, /* initproc tp_init; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
PyType_GenericNew, /* newfunc tp_new; */
@@ -118,54 +112,23 @@ PyMODINIT_FUNC UnaryFunction0D_Init( PyObject *module )
return;
Py_INCREF( &UnaryFunction0D_Type );
PyModule_AddObject(module, "UnaryFunction0D", (PyObject *)&UnaryFunction0D_Type);
UnaryFunction0DDouble_Init( module );
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds)
{
return 0;
}
void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D* self)
{
//delete self->uf0D;
self->ob_type->tp_free((PyObject*)self);
}
PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D* self)
{
return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction0D<void> *) self->uf0D)->getName().c_str(), self->uf0D );
return PyString_FromString("UnaryFunction0D");
}
PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args)
{
return PyString_FromString( ((UnaryFunction0D<void> *) self->uf0D)->getName().c_str() );
}
PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args)
{
PyObject *l;
if( !PyArg_ParseTuple(args, "O", &l) ) {
cout << "ERROR: UnaryFunction0D___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;
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus

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

@@ -18,7 +18,6 @@ extern PyTypeObject UnaryFunction0D_Type;
/*---------------------------Python BPy_UnaryFunction0D structure definition----------*/
typedef struct {
PyObject_HEAD
void *uf0D;
} BPy_UnaryFunction0D;
/*---------------------------Python BPy_UnaryFunction0D visible prototypes-----------*/

178
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DDouble.cpp
View File

@@ -1,12 +1,182 @@
PyObject *_wrap_UnaryFunction0DDouble_getName(PyObject *self , PyObject *args) {
#include "BPy_UnaryFunction0DDouble.h"
#include "../BPy_Convert.h"
#include "../Iterator/BPy_Interface0DIterator.h"
#include "UnaryFunction0D_double/BPy_DensityF0D.h"
#include "UnaryFunction0D_double/BPy_LocalAverageDepthF0D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for UnaryFunction0DDouble instance -----------*/
static int UnaryFunction0DDouble___init__(BPy_UnaryFunction0DDouble* self);
static void UnaryFunction0DDouble___dealloc__(BPy_UnaryFunction0DDouble* self);
static PyObject * UnaryFunction0DDouble___repr__(BPy_UnaryFunction0DDouble* self);
static PyObject * UnaryFunction0DDouble_getName( BPy_UnaryFunction0DDouble *self);
static PyObject * UnaryFunction0DDouble___call__( BPy_UnaryFunction0DDouble *self, PyObject *args);
/*----------------------UnaryFunction0DDouble instance definitions ----------------------------*/
static PyMethodDef BPy_UnaryFunction0DDouble_methods[] = {
{"getName", ( PyCFunction ) UnaryFunction0DDouble_getName, METH_NOARGS, "（ ）Returns the string of the name of the unary 0D function."},
{"__call__", ( PyCFunction ) UnaryFunction0DDouble___call__, METH_VARARGS, "（Interface0DIterator it ）Executes the operator () on the iterator it pointing onto the point at which we wish to evaluate the function." },
{NULL, NULL, 0, NULL}
};
/*-----------------------BPy_UnaryFunction0DDouble type definition ------------------------------*/
PyTypeObject UnaryFunction0DDouble_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"UnaryFunction0DDouble", /* tp_name */
sizeof( BPy_UnaryFunction0DDouble ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)UnaryFunction0DDouble___dealloc__, /* tp_dealloc */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
NULL, /* tp_compare */
(reprfunc)UnaryFunction0DDouble___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_UnaryFunction0DDouble_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
NULL, /* struct PyGetSetDef *tp_getset; */
&UnaryFunction0D_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)UnaryFunction0DDouble___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 UnaryFunction0DDouble_Init( PyObject *module ) {
if( module == NULL )
return;
if( PyType_Ready( &UnaryFunction0DDouble_Type ) < 0 )
return;
Py_INCREF( &UnaryFunction0DDouble_Type );
PyModule_AddObject(module, "UnaryFunction0DDouble", (PyObject *)&UnaryFunction0DDouble_Type);
if( PyType_Ready( &DensityF0D_Type ) < 0 )
return;
Py_INCREF( &DensityF0D_Type );
PyModule_AddObject(module, "DensityF0D", (PyObject *)&DensityF0D_Type);
if( PyType_Ready( &LocalAverageDepthF0D_Type ) < 0 )
return;
Py_INCREF( &LocalAverageDepthF0D_Type );
PyModule_AddObject(module, "LocalAverageDepthF0D", (PyObject *)&LocalAverageDepthF0D_Type);
}
//------------------------INSTANCE METHODS ----------------------------------
int UnaryFunction0DDouble___init__(BPy_UnaryFunction0DDouble* self)
{
self->uf0D_double = new UnaryFunction0D<double>();
return 0;
}
void UnaryFunction0DDouble___dealloc__(BPy_UnaryFunction0DDouble* self)
{
delete self->uf0D_double;
UnaryFunction0D_Type.tp_dealloc((PyObject*)self);
}
PyObject *_wrap_UnaryFunction0DDouble___call__(PyObject *self , PyObject *args) {
PyObject * UnaryFunction0DDouble___repr__(BPy_UnaryFunction0DDouble* self)
{
return PyString_FromFormat("type: %s - address: %p", self->uf0D_double->getName().c_str(), self->uf0D_double );
}
PyObject *_wrap_disown_UnaryFunction0DDouble(PyObject *self , PyObject *args) {
PyObject * UnaryFunction0DDouble_getName( BPy_UnaryFunction0DDouble *self )
{
return PyString_FromString( self->uf0D_double->getName().c_str() );
}
PyObject * UnaryFunction0DDouble___call__( BPy_UnaryFunction0DDouble *self, PyObject *args)
{
PyObject *obj;
if( !PyArg_ParseTuple(args, "O", &obj) && BPy_Interface0DIterator_Check(obj) ) {
cout << "ERROR: UnaryFunction0DDouble___call__ " << endl;
return NULL;
}
double d = self->uf0D_double->operator()(*( ((BPy_Interface0DIterator *) obj)->if0D_it ));
return PyFloat_FromDouble( d );
}
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif

34
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DDouble.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef FREESTYLE_PYTHON_UNARYFUNCTION0DDOUBLE_H
#define FREESTYLE_PYTHON_UNARYFUNCTION0DDOUBLE_H
#include "../BPy_UnaryFunction0D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject UnaryFunction0DDouble_Type;
#define BPy_UnaryFunction0DDouble_Check(v) (( (PyObject *) v)->ob_type == &UnaryFunction0DDouble_Type)
/*---------------------------Python BPy_UnaryFunction0DDouble structure definition----------*/
typedef struct {
BPy_UnaryFunction0D py_uf0D;
UnaryFunction0D<double> *uf0D_double;
} BPy_UnaryFunction0DDouble;
/*---------------------------Python BPy_UnaryFunction0DDouble visible prototypes-----------*/
PyMODINIT_FUNC UnaryFunction0DDouble_Init( PyObject *module );
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_UNARYFUNCTION0DDOUBLE_H */

122
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_DensityF0D.cpp
View File

@@ -1,12 +1,118 @@
PyObject *_wrap_DensityF0D_getName(PyObject *self , PyObject *args) {
#include "BPy_DensityF0D.h"
#include "../../../stroke/AdvancedFunctions0D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for DensityF0D instance -----------*/
static int DensityF0D___init__(BPy_DensityF0D* self, PyObject *args);
/*-----------------------BPy_DensityF0D type definition ------------------------------*/
PyTypeObject DensityF0D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"DensityF0D", /* tp_name */
sizeof( BPy_DensityF0D ), /* 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; */
&UnaryFunction0DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)DensityF0D___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 DensityF0D___init__( BPy_DensityF0D* self, PyObject *args)
{
double d = 2;
if( !PyArg_ParseTuple(args, "|d", &d) ) {
cout << "ERROR: DensityF0D___init__" << endl;
return -1;
}
self->py_uf0D_double.uf0D_double = new Functions0D::DensityF0D(d);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_DensityF0D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_DensityF0D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_DensityF0D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_DENSITYF0D_H
#define FREESTYLE_PYTHON_DENSITYF0D_H
#include "../BPy_UnaryFunction0DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject DensityF0D_Type;
#define BPy_DensityF0D_Check(v) (( (PyObject *) v)->ob_type == &DensityF0D_Type)
/*---------------------------Python BPy_DensityF0D structure definition----------*/
typedef struct {
BPy_UnaryFunction0DDouble py_uf0D_double;
} BPy_DensityF0D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_DENSITYF0D_H */

122
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_LocalAverageDepthF0D.cpp
View File

@@ -1,12 +1,118 @@
PyObject *_wrap_LocalAverageDepthF0D_getName(PyObject *self , PyObject *args) {
#include "BPy_LocalAverageDepthF0D.h"
#include "../../../stroke/AdvancedFunctions0D.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
/*--------------- Python API function prototypes for LocalAverageDepthF0D instance -----------*/
static int LocalAverageDepthF0D___init__(BPy_LocalAverageDepthF0D* self, PyObject *args);
/*-----------------------BPy_LocalAverageDepthF0D type definition ------------------------------*/
PyTypeObject LocalAverageDepthF0D_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"LocalAverageDepthF0D", /* tp_name */
sizeof( BPy_LocalAverageDepthF0D ), /* 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; */
&UnaryFunction0DDouble_Type, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
(initproc)LocalAverageDepthF0D___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 LocalAverageDepthF0D___init__( BPy_LocalAverageDepthF0D* self, PyObject *args)
{
double d = 5.0;
if( !PyArg_ParseTuple(args, "|d", &d) ) {
cout << "ERROR: LocalAverageDepthF0D___init__" << endl;
return -1;
}
self->py_uf0D_double.uf0D_double = new Functions0D::LocalAverageDepthF0D(d);
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////
PyObject *_wrap_LocalAverageDepthF0D___call__(PyObject *self , PyObject *args) {
#ifdef __cplusplus
}
PyObject *_wrap_delete_LocalAverageDepthF0D(PyObject *self , PyObject *args) {
}
#endif

30
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_LocalAverageDepthF0D.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF0D_H
#define FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF0D_H
#include "../BPy_UnaryFunction0DDouble.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////////////////
#include <Python.h>
extern PyTypeObject LocalAverageDepthF0D_Type;
#define BPy_LocalAverageDepthF0D_Check(v) (( (PyObject *) v)->ob_type == &LocalAverageDepthF0D_Type)
/*---------------------------Python BPy_LocalAverageDepthF0D structure definition----------*/
typedef struct {
BPy_UnaryFunction0DDouble py_uf0D_double;
} BPy_LocalAverageDepthF0D;
///////////////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif /* FREESTYLE_PYTHON_LOCALAVERAGEDEPTHF0D_H */