suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add planar embedding to EdgeWalker

Browse Source
This commit is contained in:
WandererFan 2016-11-13 10:15:44 -05:00 committed by wmayer
parent eb2490bb33
commit 503d718520
5 changed files with 330 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/Mod/TechDraw/App/AppTechDrawPy.cpp
View File

@ -119,12 +119,13 @@ private:
{
PyObject *pcObj;
PyObject *inclBig = Py_True;
if (!PyArg_ParseTuple(args.ptr(), "O|O", &pcObj,&inclBig)) {
throw Py::Exception();
if (!PyArg_ParseTuple(args.ptr(), "O!|O", &(PyList_Type), &pcObj, &inclBig)) {
std::string error = std::string("expected List, not ");
error += pcObj->ob_type->tp_name;
throw Base::TypeError(error);
}
std::vector<TopoDS_Edge> edgeList;
try {
Py::Sequence list(pcObj);
for (Py::Sequence::iterator it = list.begin(); it != list.end(); ++it) {
@ -177,8 +178,10 @@ private:
Py::Object findOuterWire(const Py::Tuple& args)
{
PyObject *pcObj;
if (!PyArg_ParseTuple(args.ptr(), "O", &pcObj)) {
throw Py::Exception();
if (!PyArg_ParseTuple(args.ptr(), "O!", &(PyList_Type), &pcObj)) {
std::string error = std::string("expected List, not ");
error += pcObj->ob_type->tp_name;
throw Base::TypeError(error);
}
std::vector<TopoDS_Edge> edgeList;
@ -232,10 +235,22 @@ private:
PyObject *pcObjShape;
double scale;
PyObject *pcObjDir;
if (!PyArg_ParseTuple(args.ptr(), "OdO", &pcObjShape,
if (!PyArg_ParseTuple(args.ptr(), "OdO", &pcObjShape,
&scale,
&pcObjDir)) {
throw Py::Exception();
throw Py::Exception();
}
if (!PyObject_TypeCheck(pcObjShape, &(TopoShapePy::Type))) {
std::string error = std::string("type(1) must be 'Shape', not ");
error += pcObjShape->ob_type->tp_name;
throw Base::TypeError(error);
}
if (!PyObject_TypeCheck(pcObjDir, &(Base::VectorPy::Type))) {
std::string error = std::string("type(3) must be 'Vector', not ");
error += pcObjDir->ob_type->tp_name;
throw Py::TypeError(error);
}
TopoShapePy* pShape = static_cast<TopoShapePy*>(pcObjShape);

87
src/Mod/TechDraw/App/DrawUtil.cpp
View File

@ -54,6 +54,7 @@
#include <Base/Console.h>
#include <Base/Exception.h>
#include <Base/Parameter.h>
#include <Base/Vector3D.h>
#include "DrawUtil.h"
@ -138,6 +139,92 @@ bool DrawUtil::isZeroEdge(TopoDS_Edge e)
return result;
}
//! assumes 2d on XY
//! quick angle for straight edges
double DrawUtil::angleWithX(TopoDS_Edge e, bool reverse)
{
double result = 0;
gp_Pnt gstart = BRep_Tool::Pnt(TopExp::FirstVertex(e));
Base::Vector3d start(gstart.X(),gstart.Y(),gstart.Z());
gp_Pnt gend = BRep_Tool::Pnt(TopExp::LastVertex(e));
Base::Vector3d end(gend.X(),gend.Y(),gend.Z());
Base::Vector3d u;
if (reverse) {
u = start - end;
} else {
u = end - start;
}
result = atan2(u.y,u.x);
return result;
}
double DrawUtil::angleWithX(TopoDS_Edge e, TopoDS_Vertex v)
{
double result = 0;
double param = 0;
//find tangent @ v
double adjust = 1.0; //occ tangent points in direction of curve. at lastVert we need to reverse it.
BRepAdaptor_Curve adapt(e);
if (isFirstVert(e,v)) {
param = adapt.FirstParameter();
} else if (isLastVert(e,v)) {
param = adapt.LastParameter();
adjust = -1;
} else {
//TARFU
Base::Console().Message("Error: DU::angleWithX - v is neither first nor last \n");
//must be able to get non-terminal point parm from curve/
}
Base::Vector3d uVec(0.0,0.0,0.0);
gp_Dir uDir;
BRepLProp_CLProps prop(adapt,param,2,Precision::Confusion());
if (prop.IsTangentDefined()) {
prop.Tangent(uDir);
uVec = Base::Vector3d(uDir.X(),uDir.Y(),uDir.Z()) * adjust;
} else {
//this bit is a little sketchy
gp_Pnt gstart = BRep_Tool::Pnt(TopExp::FirstVertex(e));
Base::Vector3d start(gstart.X(),gstart.Y(),gstart.Z());
gp_Pnt gend = BRep_Tool::Pnt(TopExp::LastVertex(e));
Base::Vector3d end(gend.X(),gend.Y(),gend.Z());
if (isFirstVert(e,v)) {
uVec = end - start;
} else if (isLastVert(e,v)) {
uVec = end - start;
} else {
gp_Pnt errPnt = BRep_Tool::Pnt(v);
Base::Console().Warning("angleWithX: Tangent not defined at (%.3f,%.3f,%.3f)\n",errPnt.X(),errPnt.Y(),errPnt.Z());
//throw ??????
}
}
result = atan2(uVec.y,uVec.x);
return result;
}
bool DrawUtil::isFirstVert(TopoDS_Edge e, TopoDS_Vertex v)
{
bool result = false;
TopoDS_Vertex first = TopExp::FirstVertex(e);
if (isSamePoint(first,v)) {
result = true;
}
return result;
}
bool DrawUtil::isLastVert(TopoDS_Edge e, TopoDS_Vertex v)
{
bool result = false;
TopoDS_Vertex last = TopExp::LastVertex(e);
if (isSamePoint(last,v)) {
result = true;
}
return result;
}
//based on Function provided by Joe Dowsett, 2014
double DrawUtil::sensibleScale(double working_scale)
{

5
src/Mod/TechDraw/App/DrawUtil.h
View File

@ -46,6 +46,11 @@ class TechDrawExport DrawUtil {
static bool isSamePoint(TopoDS_Vertex v1, TopoDS_Vertex v2);
static bool isZeroEdge(TopoDS_Edge e);
static double sensibleScale(double working_scale);
static double angleWithX(TopoDS_Edge e, bool reverse);
static double angleWithX(TopoDS_Edge e, TopoDS_Vertex v);
static bool isFirstVert(TopoDS_Edge e, TopoDS_Vertex v);
static bool isLastVert(TopoDS_Edge e, TopoDS_Vertex v);
//debugging routines
static void dumpVertexes(const char* text, const TopoDS_Shape& s);
static void dumpEdge(char* label, int i, TopoDS_Edge e);

166
src/Mod/TechDraw/App/EdgeWalker.cpp
View File

@ -42,6 +42,7 @@
#endif
#include <sstream>
#include <cmath>
#include <Base/Console.h>
#include <Base/Exception.h>
@ -63,17 +64,21 @@ void edgeVisitor::next_edge(Edge e)
WalkerEdge we;
we.v1 = s;
we.v2 = t;
we.ed = e;
we.idx = get(edge_index,m_g,e);
//Base::Console().Message("TRACE - EV::next_Edge - visiting (%d,%d) idx: %d\n",s,t,we.idx);
wireEdges.push_back(we);
}
void edgeVisitor::begin_face()
{
//Base::Console().Message("TRACE - EV::begin_face()\n");
wireEdges.clear();
}
void edgeVisitor::end_face()
{
//Base::Console().Message("TRACE - EV::end_face()\n");
graphWires.push_back(wireEdges);
}
@ -100,16 +105,25 @@ EdgeWalker::~EdgeWalker()
}
//loads a list of unique edges into the traversal mechanism
bool EdgeWalker::loadEdges(std::vector<TechDraw::WalkerEdge> edges)
bool EdgeWalker::loadEdges(std::vector<TechDraw::WalkerEdge>& edges)
{
for (auto e: edges) {
add_edge(e.v1,e.v2,m_g);
//Base::Console().Message("TRACE -EW::loadEdges(we)\n");
int idx = 0;
for (auto& e: edges) {
std::pair<edge_t,bool> p;
p = add_edge(e.v1,e.v2,m_g);
e.ed = p.first;
e.idx = idx;
idx++;
m_saveWalkerEdges.push_back(e);
}
return true;
}
bool EdgeWalker::loadEdges(std::vector<TopoDS_Edge> edges)
{
//Base::Console().Message("TRACE -EW::loadEdges(TopoDS)\n");
if (edges.empty()) {
throw Base::Exception("EdgeWalker has no edges to load\n");
}
@ -118,8 +132,11 @@ bool EdgeWalker::loadEdges(std::vector<TopoDS_Edge> edges)
setSize(verts.size());
std::vector<WalkerEdge> we = makeWalkerEdges(edges, verts);
loadEdges(we);
return loadEdges(we);
m_embedding = makeEmbedding(edges,verts);
return true;
}
bool EdgeWalker::setSize(int size)
{
@ -132,14 +149,24 @@ bool EdgeWalker::setSize(int size)
bool EdgeWalker::perform()
{
//Base::Console().Message("TRACE - EW::perform()\n");
// Initialize the interior edge index
//property<edge_index_t, int>
property_map<TechDraw::graph, edge_index_t>::type e_index = get(edge_index, m_g);
graph_traits<TechDraw::graph>::edges_size_type edge_count = 0;
graph_traits<TechDraw::graph>::edge_iterator ei, ei_end;
for(boost::tie(ei, ei_end) = edges(m_g); ei != ei_end; ++ei)
put(e_index, *ei, edge_count++);
//make planar embedding
planar_embedding_storage_t planar_embedding_storage(num_vertices(m_g));
planar_embedding_t planar_embedding(planar_embedding_storage.begin(),
get(vertex_index, m_g) );
for (auto& e : m_embedding) {
for (auto& i: e.incidenceList) {
planar_embedding[e.iVertex].push_back(i.eDesc);
}
}
// Test for planarity
typedef std::vector< graph_traits<TechDraw::graph>::edge_descriptor > vec_t;
std::vector<vec_t> embedding(num_vertices(m_g));
@ -148,15 +175,15 @@ bool EdgeWalker::perform()
kura_edges_t::iterator ki, ki_end;
graph_traits<TechDraw::graph>::edge_descriptor e1;
// Get the index associated with edge
// Get the index associated with edge
graph_traits<TechDraw::graph>::edges_size_type
get(boost::edge_index_t,
const TechDraw::graph& m_g,
graph_traits<TechDraw::graph>::edge_descriptor edge);
bool isPlanar = boyer_myrvold_planarity_test(boyer_myrvold_params::graph = m_g,
boyer_myrvold_params::embedding = &embedding[0],
boyer_myrvold_params::kuratowski_subgraph =
boyer_myrvold_params::embedding = &embedding[0], // this is "an" embedding but not one for finding
boyer_myrvold_params::kuratowski_subgraph = // closed regions in an edge pile.
std::back_inserter(kEdges));
if (!isPlanar) {
//TODO: remove kura subgraph to make planar??
@ -174,15 +201,14 @@ bool EdgeWalker::perform()
}
m_eV.setGraph(m_g);
//Base::Console().Message("TRACE - EW::perform - setGraph complete\n");
planar_face_traversal(m_g, &embedding[0], m_eV);
//Base::Console().Message("TRACE - EW::perform - traversal complete\n");
planar_face_traversal(m_g, &planar_embedding[0], m_eV);
return true;
}
ewWireList EdgeWalker::getResult()
{
//Base::Console().Message("TRACE - EW::getResult()\n");
ewWireList result = m_eV.getResult();
// result is a list of many wires each of which is a list of many WE
return result;
@ -190,6 +216,7 @@ ewWireList EdgeWalker::getResult()
std::vector<TopoDS_Wire> EdgeWalker::getResultWires()
{
//Base::Console().Message("TRACE - EW::getResultWires()\n");
std::vector<TopoDS_Wire> fw;
ewWireList result = m_eV.getResult();
if (result.wires.empty()) {
@ -201,7 +228,7 @@ std::vector<TopoDS_Wire> EdgeWalker::getResultWires()
std::vector<WalkerEdge>::iterator iEdge = (*iWire).wedges.begin();
std::vector<TopoDS_Edge> topoEdges;
for (;iEdge != (*iWire).wedges.end(); iEdge++) {
TopoDS_Edge e = saveInEdges.at((*iEdge).idx);
TopoDS_Edge e = m_saveInEdges.at((*iEdge).idx);
topoEdges.push_back(e);
}
TopoDS_Wire w = makeCleanWire(topoEdges); //make 1 clean wire from its edges
@ -212,6 +239,7 @@ std::vector<TopoDS_Wire> EdgeWalker::getResultWires()
std::vector<TopoDS_Wire> EdgeWalker::getResultNoDups()
{
//Base::Console().Message("TRACE - EW::getResultNoDups()\n");
std::vector<TopoDS_Wire> fw;
ewWireList result = m_eV.getResult();
if (result.wires.empty()) {
@ -225,7 +253,7 @@ std::vector<TopoDS_Wire> EdgeWalker::getResultNoDups()
std::vector<WalkerEdge>::iterator iEdge = (*iWire).wedges.begin();
std::vector<TopoDS_Edge> topoEdges;
for (;iEdge != (*iWire).wedges.end(); iEdge++) {
TopoDS_Edge e = saveInEdges.at((*iEdge).idx);
TopoDS_Edge e = m_saveInEdges.at((*iEdge).idx);
topoEdges.push_back(e);
}
TopoDS_Wire w = makeCleanWire(topoEdges); //make 1 clean wire from its edges
@ -238,6 +266,7 @@ std::vector<TopoDS_Wire> EdgeWalker::getResultNoDups()
//! make a clean wire with sorted, oriented, connected, etc edges
TopoDS_Wire EdgeWalker::makeCleanWire(std::vector<TopoDS_Edge> edges, double tol)
{
//Base::Console().Message("TRACE - EW::makeCleanWire()\n");
TopoDS_Wire result;
BRepBuilderAPI_MakeWire mkWire;
ShapeFix_ShapeTolerance sTol;
@ -268,6 +297,7 @@ TopoDS_Wire EdgeWalker::makeCleanWire(std::vector<TopoDS_Edge> edges, double tol
std::vector<TopoDS_Vertex> EdgeWalker:: makeUniqueVList(std::vector<TopoDS_Edge> edges)
{
//Base::Console().Message("TRACE - EW::makeUniqueVList()\n");
std::vector<TopoDS_Vertex> uniqueVert;
for(auto& e:edges) {
TopoDS_Vertex v1 = TopExp::FirstVertex(e);
@ -292,7 +322,8 @@ std::vector<TopoDS_Vertex> EdgeWalker:: makeUniqueVList(std::vector<TopoDS_Edge>
std::vector<WalkerEdge> EdgeWalker::makeWalkerEdges(std::vector<TopoDS_Edge> edges,
std::vector<TopoDS_Vertex> verts)
{
saveInEdges = edges;
//Base::Console().Message("TRACE - EW::makeWalkerEdges()\n");
m_saveInEdges = edges;
std::vector<WalkerEdge> walkerEdges;
for (auto e:edges) {
TopoDS_Vertex ev1 = TopExp::FirstVertex(e);
@ -305,11 +336,13 @@ std::vector<WalkerEdge> EdgeWalker::makeWalkerEdges(std::vector<TopoDS_Edge> edg
walkerEdges.push_back(we);
}
//Base::Console().Message("TRACE - EW::makeWalkerEdges - returns we: %d\n",walkerEdges.size());
return walkerEdges;
}
int EdgeWalker::findUniqueVert(TopoDS_Vertex vx, std::vector<TopoDS_Vertex> &uniqueVert)
{
//Base::Console().Message("TRACE - EW::findUniqueVert()\n");
int idx = 0;
int result = 0;
for(auto& v:uniqueVert) { //we're always going to find vx, right?
@ -324,9 +357,10 @@ int EdgeWalker::findUniqueVert(TopoDS_Vertex vx, std::vector<TopoDS_Vertex> &uni
std::vector<TopoDS_Wire> EdgeWalker::sortStrip(std::vector<TopoDS_Wire> fw, bool includeBiggest)
{
//Base::Console().Message("TRACE - EW::sortStrip()\n");
std::vector<TopoDS_Wire> sortedWires = sortWiresBySize(fw,false); //biggest 1st
if (!sortedWires.size()) {
Base::Console().Log("INFO - DVP::extractFaces - no sorted Wires!\n");
Base::Console().Log("INFO - EW::sortStrip - no sorted Wires!\n");
return sortedWires; // might happen in the middle of changes?
}
@ -395,6 +429,7 @@ std::vector<TopoDS_Wire> EdgeWalker::sortStrip(std::vector<TopoDS_Wire> fw, bool
//sort wires in order of bbox diagonal.
std::vector<TopoDS_Wire> EdgeWalker::sortWiresBySize(std::vector<TopoDS_Wire>& w, bool ascend)
{
//Base::Console().Message("TRACE - EW::sortWiresBySize()\n");
std::vector<TopoDS_Wire> wires = w;
std::sort(wires.begin(), wires.end(), EdgeWalker::wireCompare);
if (ascend) {
@ -421,6 +456,66 @@ std::vector<TopoDS_Wire> EdgeWalker::sortWiresBySize(std::vector<TopoDS_Wire>& w
return box1.SquareExtent() > box2.SquareExtent();
}
std::vector<embedItem> EdgeWalker::makeEmbedding(const std::vector<TopoDS_Edge> edges,
const std::vector<TopoDS_Vertex> uniqueVList)
{
// Base::Console().Message("TRACE - EW::makeEmbedding(edges: %d, verts: %d)\n",
// edges.size(),uniqueVList.size());
std::vector<embedItem> result;
int iv = 0;
for (auto& v: uniqueVList) {
int ie = 0;
std::vector<incidenceItem> iiList;
for (auto& e: edges) {
double angle = 0;
if (DrawUtil::isFirstVert(e,v)) {
angle = DrawUtil::angleWithX(e,v);
incidenceItem ii(ie, angle, m_saveWalkerEdges[ie].ed);
iiList.push_back(ii);
} else if (DrawUtil::isLastVert(e,v)) {
angle = DrawUtil::angleWithX(e,v);
incidenceItem ii(ie, angle, m_saveWalkerEdges[ie].ed);
iiList.push_back(ii);
} else {
//Base::Console().Message("TRACE - EW::makeEmbedding - neither first nor last\n");
}
ie++;
}
//sort incidenceList by angle
iiList = embedItem::sortIncidenceList(iiList, false);
embedItem embed(iv, iiList);
result.push_back(embed);
iv++;
}
return result;
}
//! get incidence row as edge indices for v'th vertex
std::vector<int> EdgeWalker::getEmbeddingRowIx(int v)
{
// //Base::Console().Message("TRACE - EW::getEmbeddingRowIx(%d)\n",v);
std::vector<int> result;
embedItem ei = m_embedding[v];
for (auto& ii: ei.incidenceList) {
result.push_back(ii.iEdge);
}
return result;
}
//! get incidence row as edgeDescriptors for v'th vertex
std::vector<edge_t> EdgeWalker::getEmbeddingRow(int v)
{
// //Base::Console().Message("TRACE - EW::getEmbeddingRow(%d)\n",v);
std::vector<edge_t> result;
embedItem ei = m_embedding[v];
for (auto& ii: ei.incidenceList) {
result.push_back(ii.eDesc);
}
return result;
}
//*******************************************
// WalkerEdge Methods
@ -468,6 +563,10 @@ void ewWire::push_back(WalkerEdge w)
wedges.push_back(w);
}
int ewWire::size(void)
{
return wedges.size();
}
//***************************************
// ewWireList methods
@ -500,3 +599,40 @@ void ewWireList::push_back(ewWire w)
{
wires.push_back(w);
}
int ewWireList::size(void)
{
return wires.size();
}
//*************************************
//* embedItem Methods
//*************************************
std::string embedItem::dump(void)
{
std::string result;
std::stringstream builder;
builder << "embedItem - vertex: " << iVertex << " incidenceList: ";
for (auto& ii : incidenceList) {
builder << "e:" << ii.iEdge << "/a:" << (ii.angle * (180.0/M_PI)) << "/ed: " << ii.eDesc;
}
result = builder.str();
return result;
}
/*static*/ bool embedItem::iiCompare(incidenceItem i1, incidenceItem i2)
{
return (i1.angle > i2.angle);
}
std::vector<incidenceItem> embedItem::sortIncidenceList (std::vector<incidenceItem> &list, bool ascend)
{
//Base::Console().Message("TRACE - eI::sortIncidenceList()\n");
std::vector< incidenceItem > tempList = list;
std::sort(tempList.begin(), tempList.end(), embedItem::iiCompare);
if (ascend) {
std::reverse(tempList.begin(),tempList.end());
}
return tempList;
}

75
src/Mod/TechDraw/App/EdgeWalker.h
View File

@ -47,14 +47,32 @@
namespace TechDraw {
using namespace boost;
typedef adjacency_list
< vecS,
vecS,
undirectedS,
property<vertex_index_t, int>,
property<edge_index_t, int>
>
graph;
typedef
adjacency_list
< vecS,
vecS,
undirectedS,
property<vertex_index_t, int>,
property<edge_index_t, int>
>
graph;
typedef
graph_traits < graph >::vertex_descriptor
vertex_t;
typedef
graph_traits < graph >::edge_descriptor
edge_t;
typedef
std::vector< std::vector<edge_t> >
planar_embedding_storage_t;
typedef
boost::iterator_property_map< planar_embedding_storage_t::iterator,
property_map<graph, vertex_index_t>::type
>
planar_embedding_t;
class WalkerEdge
{
@ -64,6 +82,7 @@ public:
std::size_t v1;
std::size_t v2;
edge_t ed;
int idx;
};
@ -75,6 +94,7 @@ public:
std::vector<WalkerEdge> wedges; //[WE] representing 1 wire
void push_back(WalkerEdge w);
void clear() {wedges.clear();};
int size(void);
};
class ewWireList
@ -84,6 +104,7 @@ public:
std::vector<ewWire> wires;
void push_back(ewWire e);
int size(void);
};
@ -104,13 +125,41 @@ private:
TechDraw::graph m_g;
};
class incidenceItem
{
public:
incidenceItem() {}
incidenceItem(int idx, double a, edge_t ed) {iEdge = idx; angle = a; eDesc = ed;}
~incidenceItem() {}
int iEdge;
double angle;
edge_t eDesc;
};
class embedItem
{
public:
embedItem();
embedItem(int i,
std::vector<incidenceItem> list) { iVertex = i; incidenceList = list;}
~embedItem() {}
int iVertex;
std::vector<incidenceItem> incidenceList;
std::string dump(void);
static std::vector<incidenceItem> sortIncidenceList (std::vector<incidenceItem> &list, bool ascend);
static bool iiCompare(incidenceItem i1, incidenceItem i2);
};
class EdgeWalker
{
public:
EdgeWalker(void);
virtual ~EdgeWalker();
bool loadEdges(std::vector<TechDraw::WalkerEdge> edges);
bool loadEdges(std::vector<TechDraw::WalkerEdge>& edges);
bool loadEdges(std::vector<TopoDS_Edge> edges);
bool setSize(int size);
bool perform();
@ -127,10 +176,16 @@ public:
std::vector<TopoDS_Wire> sortWiresBySize(std::vector<TopoDS_Wire>& w, bool reverse = false);
TopoDS_Wire makeCleanWire(std::vector<TopoDS_Edge> edges, double tol = 0.10);
std::vector<int> getEmbeddingRowIx(int v);
std::vector<edge_t> getEmbeddingRow(int v);
std::vector<embedItem> makeEmbedding(const std::vector<TopoDS_Edge> edges,
const std::vector<TopoDS_Vertex> uniqueVList);
protected:
static bool wireCompare(const TopoDS_Wire& w1, const TopoDS_Wire& w2);
std::vector<TopoDS_Edge> saveInEdges;
std::vector<TechDraw::WalkerEdge> m_saveWalkerEdges;
std::vector<TopoDS_Edge> m_saveInEdges;
std::vector<embedItem> m_embedding;
private:
edgeVisitor m_eV;