Elements* disconnectVertex (Hexa* maille, Vertex* noeud);
Elements* disconnectEdges (Hexas thexas, Edges edges);
- Elements* replace (Quads pattern, Vertex* p1, Vertex* c1,
- Vertex* p2, Vertex* c2, Vertex* p3, Vertex* c3);
-
- Elements* replaceHexas (Quads pattern, Quads cible, Vertex* p1, Vertex* c1,
- Vertex* p2, Vertex* c2, Vertex* p3, Vertex* c3);
+ Elements* replace (Quads pattern, Quads cible, Vertex* p1, Vertex* c1,
+ Vertex* p2, Vertex* c2);
int mergeVertices (Vertex* v1, Vertex* v2);
int mergeEdges (Edge* e1, Edge* e2, Vertex* v1, Vertex* v2);
void clearAssoEdges ();
void clearAssoQuads ();
+ // PERIMES
+ Elements* replaceHexa (Quads pattern, Vertex* p1, Vertex* c1, Vertex* p2,
+ Vertex* c2, Vertex* p3, Vertex* c3);
+ Elements* replace (Quads pattern, Vertex* p1, Vertex* c1, Vertex* p2,
+ Vertex* c2, Vertex* p3, Vertex* c3)
+ { return replaceHexa (pattern, p1, c1, p2, c2, p3, c3); }
+
+ Elements* replaceHexas (Quads pattern, Quads cible, Vertex* p1, Vertex* c1,
+ Vertex* p2, Vertex* c2, Vertex* p3, Vertex* c3)
+ { return replace (pattern, cible, p1, c1, p2, c2); }
+
+
public:
~Document ();
Hexa* hexa = new Hexa (q_a, q_b, q_c, q_d, q_e, q_f);
return hexa;
}
-// ========================================================= replace
-Elements* Document::replace (Quads pattern, Vertex* p1, Vertex* c1,
+// ========================================================= replaceHexa
+Elements* Document::replaceHexa (Quads pattern, Vertex* p1, Vertex* c1,
Vertex* p2, Vertex* c2, Vertex* p3, Vertex* c3)
{
- DumpStart ("replace", pattern << p1 << c1 << p2 << c2 << p3 << c3);
+ DumpStart ("replaceHexa", pattern << p1 << c1 << p2 << c2 << p3 << c3);
Elements* t_hexas = new Elements (this);
int ier = t_hexas->replaceHexas (pattern, p1, c1, p2, c2, p3, c3);
DumpReturn (t_hexas);
return t_hexas;
}
+// ========================================================= repla
+Elements* Document::replace (Quads motif, Quads cible, Vertex* p1, Vertex* c1, Vertex* p2, Vertex* c2)
+{
+ DumpStart ("replace", motif << cible << p1 << c1 << p2 << c2);
+
+ Elements* t_hexas = new Elements (this);
+
+ //if (BadElement (edge))
+ {
+ t_hexas->setError (HERR);
+ Mess << "This function is not yet implemented";
+ }
+
+ DumpReturn (t_hexas);
+ return t_hexas;
+}
// ========================================================= print_replace
void print_replace (Edge* zig, Edge* zag)
{
DumpReturn (grid);
return grid;
}
-// ========================================================= replaceHexas
-Elements* Document::replaceHexas (Quads pattern, Quads cible, Vertex* p1,
- Vertex* c1, Vertex* p2, Vertex* c2,
- Vertex* p3, Vertex* c3)
-{
- DumpStart ("replace", pattern << cible << p1 << c1 << p2 << c2 << p3 << c3);
-
- Elements* t_hexas = new Elements (this);
-
- //if (BadElement (edge))
- {
- t_hexas->setError (HERR);
- Mess << "This function is not yet implemented";
- }
-
- DumpReturn (t_hexas);
- return t_hexas;
-}
END_NAMESPACE_HEXA
#include "HexXmlWriter.hxx"
#include "HexNewShape.hxx"
#include "HexAssoEdge.hxx"
+#include "HexVertexShape.hxx"
static int niveau = 0;
double longueur = calc_distance (p1, p2);
return longueur;
}
+// ========================================================= findAssociation
+int Edge::findAssociation (NewShape* geom)
+{
+ Real3 point, p2;
+ if (geom==NULL)
+ return NOTHING;
+
+ e_vertex [V_AMONT]-> getAssoCoord (point);
+ e_vertex [V_AVAL ]-> getAssoCoord (p2);
+
+ EdgeShape* gline = geom->findEdge (point, p2);
+ if (gline==NULL)
+ {
+ cout << " *** FindAssociation " << el_name << endl;
+ for (int nv=0 ; nv < V_TWO ; ++nv)
+ {
+ e_vertex [nv]-> getAssoCoord (point);
+ VertexShape* shape = geom->findVertex (point);
+ cout << " *** Vertex nro " << nv;
+ if (shape==NULL)
+ {
+ cout << " absent : ";
+ PutCoord (point);
+ }
+ else
+ {
+ cout << " : Subid = " << shape->getIdent() << endl;
+ }
+ }
+ return NOTHING;
+ }
+
+ clearAssociation ();
+ addAssociation (gline, 0, 1);
+ return gline->getIdent();
+}
+// ========================================================= setAssociation
+int Edge::setAssociation (NewShape* geom, int subid)
+{
+ if (geom == NULL)
+ {
+ if (el_root->debug ())
+ cout << " Edge " << el_name << " addAssociation of NULL ignored"
+ << endl;
+ return HERR;
+ }
+
+ EdgeShape* gline = geom->findEdge (subid);
+ if (gline == NULL)
+ {
+ if (el_root->debug ())
+ cout << " Edge " << el_name << " addAssociation bad subid : "
+ << subid << endl;
+ return HERR;
+ }
+
+ Real3 p1, p2, pa, pb;
+ gline->getCoords (p1, p2);
+ e_vertex [V_AMONT]-> getAssoCoord (pa);
+ e_vertex [V_AVAL ]-> getAssoCoord (pb);
+
+ double da1 = calc_d2 (pa, p1);
+ double da2 = calc_d2 (pa, p2);
+ double db1 = calc_d2 (pb, p1);
+ double db2 = calc_d2 (pb, p2);
+
+ cout << "setAssociation " << el_name << " :" <<endl;
+
+ if (da2 < da1 && db1 < db2)
+ {
+ e_vertex [V_AMONT]->setAssociation (p2);
+ e_vertex [V_AVAL ]->setAssociation (p1);
+ }
+ else
+ {
+ e_vertex [V_AMONT]->setAssociation (p1);
+ e_vertex [V_AVAL ]->setAssociation (p2);
+ }
+
+
+ clearAssociation ();
+ int ier = addAssociation (gline, 0, 1);
+ return ier;
+}
END_NAMESPACE_HEXA
public:
virtual Vertex* getVertex (int nro);
- int addAssociation (NewShape* geom, int subid, double deb, double fin);
+ int addAssociation (NewShape* geom, int subid, double deb, double fin);
+ int setAssociation (NewShape* geom, int subid);
+ int findAssociation (NewShape* geom);
virtual void clearAssociation ();
void setColor (double valeur);
bool getWay () { return e_way ; }
// ========================================================= samePoints
bool EdgeShape::samePoints (double* point1, double* point2)
{
- const double Epsilon2 = 1e-6;
+ const double Epsilon2 = 1e-4;
bool rep = same_coords (point1, point2, Epsilon2);
return rep;
}
else
return NOTHING;
}
+// ========================================================= definedBy
+bool EdgeShape::definedBy (double p1[], double p2[])
+{
+ if (maj_curve)
+ updateCurve ();
+
+ bool rep = false;
+ if (samePoints (p1, lin_start))
+ rep = samePoints (p2, lin_end);
+ else if (samePoints (p1, lin_end))
+ rep = samePoints (p2, lin_start);
+ return rep;
+}
// ========================================================= getParam
double EdgeShape::getParam (double* coord)
{
lin_radius = lin_angle = 0;
kind_of = (EnumKindOfShape) adapt_curve.GetType();
+#ifndef NO_CASCADE
if (kind_of==KS_Circle)
{
Handle(Geom_Circle) hgc = Handle(Geom_Circle)::DownCast (handle);
lin_radius = hgc->Radius ();
lin_angle = (par_maxi-par_mini)*180/M_PI;
- PutData (lin_radius);
- PutData (lin_angle);
}
+#endif
}
// ====================================================== getAngle
double EdgeShape::getAngle ()
double getRadius ();
double getAngle ();
int onExtremity (double point[]);
+ bool definedBy (double p1[], double p2[]);
bool isLinear () { return kind_of == KS_Line ; }
static bool samePoints (double point1[], double point2[]);
}
return NULL;
}
+// ====================================================== findVertex
+VertexShape* NewShape::findVertex (double point[])
+{
+ int nbre = tab_vertex.size ();
+ for (int nro=0 ; nro < nbre ; nro++)
+ {
+ VertexShape* shape = tab_vertex [nro];
+ if (shape->definedBy (point))
+ return shape;
+ }
+ return NULL;
+}
// ====================================================== findEdge
EdgeShape* NewShape::findEdge (int shid)
{
}
return NULL;
}
+// ====================================================== findEdge
+EdgeShape* NewShape::findEdge (double p1[], double p2[])
+{
+ int nbre = tab_edge.size ();
+ for (int nro=0 ; nro < nbre ; nro++)
+ {
+ EdgeShape* shape = tab_edge [nro];
+ if (shape->definedBy (p1, p2))
+ return shape;
+ }
+ return NULL;
+}
// ====================================================== findFace
FaceShape* NewShape::findFace (int shid)
{
void addAssociation (Quad* elt, int subid);
VertexShape* findVertex (int subid);
+ VertexShape* findVertex (double point[]);
EdgeShape* findEdge (int subid);
+ EdgeShape* findEdge (double p1[], double p2[]);
FaceShape* findFace (int subid);
SubShape* findSubShape (int subid);
+
const TopoDS_Shape& getGeoShape (int subid);
int saveBrep ();
py = ss_coord[dir_y];
pz = ss_coord[dir_z];
}
+#if 0
// ====================================================== getShape
const TopoDS_Shape& VertexShape::getShape()
{
return SubShape::getShape ();
}
+#endif
// ====================================================== addAssociation
void VertexShape::addAssociation (Vertex* elt)
{
else
return NULL;
}
+// ====================================================== definedBy
+bool VertexShape::definedBy (double point[])
+{
+ if (maj_coords)
+ updateCoords ();
+
+ const double Epsilon2 = 1e-4;
+ bool rep = same_coords (point, ss_coord, Epsilon2);
+ return rep;
+}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// ====================================================== saveXml
void VertexShape::saveXml (XmlWriter* xml)
void getCoords (double& px, double& py, double& pz);
void saveXml (XmlWriter* xml);
- virtual const TopoDS_Shape& getShape(); // #mbarry
+ // virtual const TopoDS_Shape& getShape(); // #mbarry
+ bool definedBy (double point[]);
private :
void updateCoords ();
HexaExport double calc_norme (double v1[]);
HexaExport double calc_distance (double v1[], double v2[]);
+HexaExport double calc_d2 (double v1[], double v2[]);
HexaExport void calc_vecteur (double pta[], double ptb[], double vab[]);
HexaExport void copy_vecteur (double va [], double vb []);
HexaExport void calc_milieu (double pta[], double ptb[], double milieu[]);
Real3 vv = { v2[dir_x]-v1[dir_x], v2[dir_y]-v1[dir_y], v2[dir_z]-v1[dir_z] };
return calc_norme (vv);
}
+// ======================================================== calc_d2
+double calc_d2 (double v1[], double v2[])
+{
+ double dd = carre (v2[dir_x]-v1[dir_x]) + carre (v2[dir_y]-v1[dir_y])
+ + carre (v2[dir_z]-v1[dir_z]);
+ return dd;
+}
// ========================================================= calc_vecteur
void calc_vecteur (double pta[], double ptb[], double vab[])
{
void deleteQuadItem();
void deleteQuadItem2();
void updateButtonBox();
+ void updateHelpFileName();
private:
HEXA_NS::Elements *_value;
rad2degres = _hexablock_swig.rad2degres
calc_norme = _hexablock_swig.calc_norme
calc_distance = _hexablock_swig.calc_distance
+calc_d2 = _hexablock_swig.calc_d2
calc_vecteur = _hexablock_swig.calc_vecteur
copy_vecteur = _hexablock_swig.copy_vecteur
calc_milieu = _hexablock_swig.calc_milieu
__repr__ = _swig_repr
def getVertex(*args): return _hexablock_swig.Edge_getVertex(*args)
def addAssociation(*args): return _hexablock_swig.Edge_addAssociation(*args)
+ def setAssociation(*args): return _hexablock_swig.Edge_setAssociation(*args)
+ def findAssociation(*args): return _hexablock_swig.Edge_findAssociation(*args)
def clearAssociation(*args): return _hexablock_swig.Edge_clearAssociation(*args)
def setColor(*args): return _hexablock_swig.Edge_setColor(*args)
def getWay(*args): return _hexablock_swig.Edge_getWay(*args)
}
+SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ double *arg1 ;
+ double *arg2 ;
+ double result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
+ }
+ arg1 = reinterpret_cast< double * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = reinterpret_cast< double * >(argp2);
+ result = (double)Hex::calc_d2(arg1,arg2);
+ resultobj = SWIG_From_double(static_cast< double >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
double *arg1 ;
}
+SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ Hex::Edge *arg1 = (Hex::Edge *) 0 ;
+ Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
+ int arg3 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
+ }
+ arg1 = reinterpret_cast< Hex::Edge * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
+ }
+ arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
+ ecode3 = SWIG_AsVal_int(obj2, &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
+ result = (int)(arg1)->setAssociation(arg2,arg3);
+ resultobj = SWIG_From_int(static_cast< int >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ Hex::Edge *arg1 = (Hex::Edge *) 0 ;
+ Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
+ int result;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+
+ if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
+ }
+ arg1 = reinterpret_cast< Hex::Edge * >(argp1);
+ res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
+ }
+ arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
+ result = (int)(arg1)->findAssociation(arg2);
+ resultobj = SWIG_From_int(static_cast< int >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
Hex::Edge *arg1 = (Hex::Edge *) 0 ;
PyObject *resultobj = 0;
Hex::Document *arg1 = (Hex::Document *) 0 ;
Hex::Quads arg2 ;
- Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
+ Hex::Quads arg3 ;
Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
- Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
Hex::Elements *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
void *argp5 = 0 ;
int res6 = 0 ;
void *argp7 = 0 ;
int res7 = 0 ;
- void *argp8 = 0 ;
- int res8 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj4 = 0 ;
PyObject * obj5 = 0 ;
PyObject * obj6 = 0 ;
- PyObject * obj7 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
+ if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
arg2 = *ptr;
if (SWIG_IsNewObj(res)) delete ptr;
}
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Vertex *""'");
+ {
+ std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *ptr = (std::vector<Hex::Quad*,std::allocator<Hex::Quad * > > *)0;
+ int res = swig::asptr(obj2, &ptr);
+ if (!SWIG_IsOK(res) || !ptr) {
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
+ }
+ arg3 = *ptr;
+ if (SWIG_IsNewObj(res)) delete ptr;
}
- arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
}
arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
- res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 | 0 );
- if (!SWIG_IsOK(res8)) {
- SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_replace" "', argument " "8"" of type '" "Hex::Vertex *""'");
- }
- arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
- result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+ result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 | 0 );
return resultobj;
fail:
{ (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
{ (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
{ (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
+ { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
{ (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
{ (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
{ (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
{ (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
{ (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
{ (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
+ { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
+ { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
{ (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
{ (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
{ (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
