Skip to content
GitLab
Commit 5c53f444 authored by Beuster's avatar Beuster
Browse files

Expand file HealingBySweepPlanarity.java 

Transfer the basic cpp code skeleton

Use as guideline for code conversion
parent d5194fe2
Hide whitespace changes
Inline Side-by-side
CityDoctorParent/Extensions/CityDoctorHealer/src/main/java/de/hft/stuttgart/citydoctor2/healer/bht/HealingBySweepPlanarity.java
View file @ 5c53f444
......@@ -32,6 +32,23 @@ public class HealingBySweepPlanarity {
// public Point3dList getComplexPoints(Face cpFace)
// {
//
// Point3dList multiplePoints = new Point3dList();
//
// VertexList vertices = getAllVerticesForFace(cpFace);
//
// for (Vertex pVertex : vertices)
// {
// Point3d point = pVertex.getPositionOnGeometry();
// LinkedList<Edge > otherEdges = getOtherEdges(pVertex, cpFace);
//
// if (otherEdges.size() >= 2)
// {
// multiplePoints.push_back(pVertex.getPositionOnGeometry());
// }
// }
//
// return new Point3dList(multiplePoints);
//
// }
......@@ -39,6 +56,258 @@ public class HealingBySweepPlanarity {
// public LinkedList<Vertex > splitVertexCut(Vertex pVertexToSplit, Face pSweepFace)
// {
//
// LinkedList<Vertex > allSplitVertices = new LinkedList<Vertex >();
//
// LinkedList<Face > allFacesOfVertex = getFacesForVertex(pVertexToSplit);
// LinkedList<SplitCutTriple> unsortedTriple = new LinkedList<SplitCutTriple>();
// for (Face middleFace : allFacesOfVertex)
// {
//
// SplitCutTriple aTriple = new SplitCutTriple();
//
// aTriple.pFace_center = middleFace;
//
// LinkedList<Edge > faceEdges = getAllEdgesForFace(pVertexToSplit, middleFace);
// if (faceEdges.size() != 2)
// {
// EDGE_ERROR << "there should be two edges. faceEdges.size() = " << faceEdges.size() << EDGE_ENDL;
// System.out.print("there should be two edges. faceEdges.size() = ");
// System.out.print(faceEdges.size());
// System.out.println();
//
// for (Edge pTempEdge : faceEdges)
// {
// System.out.print(" ");
// System.out.print(pTempEdge);
// System.out.println();
// }
//
// return new LinkedList<Vertex>();
// }
//
// aTriple.pEdge_left = faceEdges.getFirst();
// aTriple.pEdge_rigth = faceEdges.getLast();
//
// aTriple.pFace_left = (Face)getFacePartner(faceEdges.getFirst(), middleFace);
// aTriple.pFace_rigth = (Face)getFacePartner(faceEdges.getLast(), middleFace);
//
// unsortedTriple.addLast(aTriple);
// }
//
// LinkedList<SplitCutTriple> sortedTriples = sortSplitCutTriples(unsortedTriple, pSweepFace);
//
//
// // only output
//
// /* cout << "main Face : " << pSweepFace << "\n";
// System.out.print("main vertex : ");
// System.out.print(pVertexToSplit);
// System.out.println();
// for (Face pFaceOfAll : allFacesOfVertex)
// {
// System.out.print(" one of the faces : ");
// System.out.print(pFaceOfAll);
// ystem.out.println();
// }
// for (SplitCutTriple aTriple : sortedTriples)
// {
// System.out.print(" Triple ");
// System.out.println();
// System.out.print(" right Face : ");
// System.out.print(aTriple.pFace_left);
// System.out.println();
// System.out.print(" middle Face : ");
// System.out.print(aTriple.pFace_center);
// System.out.println();
// System.out.print(" left Face : ");
// System.out.print(aTriple.pFace_rigth);
// System.out.println();
// System.out.print(" right Edge : ");
// System.out.print(aTriple.pEdge_left);
// System.out.println();
// System.out.print(" left Edge : ");
// System.out.print(aTriple.pFace_rigth);
// System.out.println();
//
// }*/
//
// // only output end
//
// LinkedList<Edge> allUnprocessedEdgesOfVertex;
// for (Base baseElement : pVertexToSplit.getEdges())
// {
// allUnprocessedEdgesOfVertex.push_back((Edge)baseElement);
// }
//
// Vertex pLastVertex = pVertexToSplit;
// Point3d pointCopy = pVertexToSplit.getPositionOnGeometry();
//
// CoEdge pNewCenterCoEdge = null;
// CoEdge pNewMainCoEdge = null;
//
// for (SplitCutTriple aTriple : sortedTriples)
// {
// if (aTriple.pFace_rigth == pSweepFace || aTriple.pFace_center == pSweepFace)
// {
// //System.out.print("don't have to process first and last triple");
// //System.out.println();
// allUnprocessedEdgesOfVertex.remove(aTriple.pEdge_rigth);
// }
// else if (aTriple.pFace_left == pSweepFace)
// {
// //System.out.print("don't have to process second triple - just to push the first pair<Vertex *, Edge *>");
// //System.out.println();
// allSplitVertices.addLast(pLastVertex);
// allUnprocessedEdgesOfVertex.remove(aTriple.pEdge_rigth);
// }
// else
// {
//
// // duplicate vertex
// Vertex pNewVertex = new Vertex(pointCopy);
// allSplitVertices.addLast(pNewVertex);
// //System.out.print("duplicated vertex ");
// //System.out.print(pNewVertex);
// //System.out.println();
//
// // set some of the edgepoints to duplicated one
// for (Edge pEdgeToSet : allUnprocessedEdgesOfVertex)
// {
// //System.out.print("start : ");
// //System.out.print(pEdgeToSet.getStartVertex());
// //System.out.print(" end : ");
// //System.out.print(pEdgeToSet.getEndVertex());
// //System.out.println();
// if (pEdgeToSet.getStartVertex() == pLastVertex)
// {
// pEdgeToSet.setStartVertex(pNewVertex);
// }
// else if (pEdgeToSet.getEndVertex() == pLastVertex)
// {
// pEdgeToSet.setEndVertex(pNewVertex);
// }
// else
// {
// EDGE_ERROR << "edge does not contain vertex" << EDGE_ENDL;
// }
// }
//
// // create Edge (between last and new vertex) and CoEdges
// GmStraight gmStraight = new GmStraight(pLastVertex.getPositionOnGeometry(), pNewVertex.getPositionOnGeometry());
// Straight straight = new Straight(gmStraight);
// Edge pNewEdge = new Edge(straight, Topology.FORWARD, pLastVertex, pNewVertex);
//
// // get the two loops
// Loop pLoopCenter = (Loop)aTriple.pFace_center.getLoop();
// Loop pLoopMain = (Loop)pSweepFace.getLoop();
//
// // get the corresponding coedges of the loops
// CoEdge pCoEdgeCenterRight = getCorrespondingCoEdge(aTriple.pEdge_rigth, aTriple.pFace_center);
// CoEdge pCoEdgeCenterLeft = getCorrespondingCoEdge(aTriple.pEdge_left, aTriple.pFace_center);
// CoEdge pCoEdgeMainRight = getCorrespondingCoEdge(sortedTriples.getFirst().pEdge_rigth, pSweepFace);
// CoEdge pCoEdgeMainLeft = getCorrespondingCoEdge(sortedTriples.getFirst().pEdge_left, pSweepFace);
// if (pNewMainCoEdge != null)
// {
// pCoEdgeMainRight = pNewMainCoEdge;
// }
//
// // get the previous and next coedge as well as the sense for the new center coEdge
// CoEdge pCoEdgeCenterNext = null;
// CoEdge pCoEdgeCenterPrev = null;
// Topology.Sense centerSense = Topology.UNKNOWN;
// Topology.Sense mainSense = Topology.UNKNOWN;
//
// if (pCoEdgeCenterRight.getPrevious() == pCoEdgeCenterLeft)
// {
// pCoEdgeCenterPrev = pCoEdgeCenterLeft;
// pCoEdgeCenterNext = pCoEdgeCenterRight;
// centerSense = Topology.FORWARD;
// mainSense = Topology.REVERSED;
// }
// else if (pCoEdgeCenterRight.getNext() == pCoEdgeCenterLeft)
// {
// pCoEdgeCenterNext = pCoEdgeCenterLeft;
// pCoEdgeCenterPrev = pCoEdgeCenterRight;
// centerSense = Topology.REVERSED;
// mainSense = Topology.FORWARD;
// }
// else
// {
// EDGE_ERROR << "prev and next not found for center" << EDGE_ENDL;
// }
//
// // ..same for the new main coEdge
// CoEdge pCoEdgeMainNext = null;
// CoEdge pCoEdgeMainPrev = null;
//
// if (pCoEdgeMainRight.getPrevious() == pCoEdgeMainLeft)
// {
// pCoEdgeMainPrev = pCoEdgeMainLeft;
// pCoEdgeMainNext = pCoEdgeMainRight;
// }
// else if (pCoEdgeMainRight.getNext() == pCoEdgeMainLeft)
// {
// pCoEdgeMainNext = pCoEdgeMainLeft;
// pCoEdgeMainPrev = pCoEdgeMainRight;
// }
// else
// {
// EDGE_ERROR << "prev and next not found for main" << EDGE_ENDL;
// }
//
// // create the new coedges and set relations to other coedges
// pNewCenterCoEdge = new CoEdge(pNewEdge, centerSense);
// pNewMainCoEdge = new CoEdge(pNewEdge, mainSense);
// setGeometryForCoEdge(pNewCenterCoEdge);
// setGeometryForCoEdge(pNewMainCoEdge);
//
// pNewCenterCoEdge.setPartner(pNewMainCoEdge);
// pNewMainCoEdge.setPartner(pNewCenterCoEdge);
//
// pNewCenterCoEdge.setNext(pCoEdgeCenterNext);
// pNewCenterCoEdge.setPrevious(pCoEdgeCenterPrev);
//
// pNewMainCoEdge.setNext(pCoEdgeMainNext);
// pNewMainCoEdge.setPrevious(pCoEdgeMainPrev);
//
// // add CoEdges to loop
// pLoopCenter.addCoEdge(pNewCenterCoEdge);
// pLoopMain.addCoEdge(pNewMainCoEdge);
//
//
// // output
// if (mPrintInfo)
// {
// System.out.print(" SPLIT VERTEX (CUT) ");
// System.out.print(pLastVertex);
// System.out.print(" NEW VERTEX : ");
// System.out.print(pNewVertex);
// System.out.print(" NEW EDGE : ");
// System.out.print(pNewEdge);
// System.out.println();
// }
//
//
// // set up for next iteration
// //cout << "allUnprocessedEdgesOfVertex.size before " << allUnprocessedEdgesOfVertex.size() << endl;
// allUnprocessedEdgesOfVertex.remove(aTriple.pEdge_rigth);
// //cout << "allUnprocessedEdgesOfVertex.size after " << allUnprocessedEdgesOfVertex.size() << endl;
// pLastVertex = pNewVertex;
//
// // save changes in Trackchanges
// mpBuilding.getTrackChanges().addNewVertex(pNewVertex);
// for (Face cpFace : getFacesForVertex(pNewVertex))
// {
// mpBuilding.getTrackChanges().changeFace((Face)cpFace);
// }
// }
//
// } // for(SplitCutTriple aTriple : sortedTriples)
//
//
// return new LinkedList<Vertex >(allSplitVertices);
//
//
// }
......@@ -46,13 +315,233 @@ public class HealingBySweepPlanarity {
// public LinkedList<HealingBySweepPlanarity.SplitCutTriple> sortSplitCutTriples(LinkedList<SplitCutTriple> unsortedTriples, Face pMainFace)
// {
//
// LinkedList<SplitCutTriple> sortedTriples = new LinkedList<SplitCutTriple>();
//
// for (SplitCutTriple aTriple : unsortedTriples)
// {
// if (aTriple.pFace_center == pMainFace)
// {
// sortedTriples.addLast(aTriple);
// unsortedTriples.remove(aTriple);
// break;
// }
// }
//
// Face pCurrFace = sortedTriples.getFirst().pFace_center;
// Face pNextFace = sortedTriples.getFirst().pFace_rigth;
//
// while (unsortedTriples.size() != 0)
// {
//
// for (SplitCutTriple aTriple : unsortedTriples)
// {
// if (aTriple.pFace_center == pNextFace)
// {
//
// if (aTriple.pFace_rigth == pCurrFace)
// {
// Edge pTempEdge = aTriple.pEdge_left;
// aTriple.pEdge_left = aTriple.pEdge_rigth;
// aTriple.pEdge_rigth = pTempEdge;
//
// Face pTempFace = aTriple.pFace_left;
// aTriple.pFace_left = aTriple.pFace_rigth;
// aTriple.pFace_rigth = pTempFace;
// }
//
// pNextFace = aTriple.pFace_rigth;
// pCurrFace = aTriple.pFace_center;
//
// sortedTriples.addLast(aTriple);
// unsortedTriples.remove(aTriple);
// break; // break for loop and try to find next Triple in line
// }
// }
// }
//
//
//
// return new LinkedList<SplitCutTriple>(sortedTriples);
//
// }
//
// public Vertex splitVertexPull(Vertex pVertexToSplit, Face pFaceToSweep, final LinkedList<Face> newNeighborFaces, LinkedList<Edge > edgesToElongateList)
// {
//
// // --------------------------------------------------------------------
// // check if there are 2 neighbor faces of pFaceToSweep that are connected to the vertex
// // --------------------------------------------------------------------
//
// if (newNeighborFaces.size() != 2)
// {
// EDGE_WARNING << " size of newNeighborFaces should be 2 - this case is not handled yet " << EDGE_ENDL;
// EDGE_WARNING << " this occures for face " << pFaceToSweep << " and vertex " << pVertexToSplit << "." << EDGE_ENDL;
// }
//
// // --------------------------------------------------------------------
// // get the two planes of the neighbor faces
// // --------------------------------------------------------------------
//
// Face cpNeighborFace1 = newNeighborFaces.getFirst();
// Face cpNeighborFace2 = newNeighborFaces.getLast();
// Surface cpSurface1 = cpNeighborFace1.getGeometry();
// Surface cpSurface2 = cpNeighborFace2.getGeometry();
// if (!cpSurface1.isOfType(Plane.getClassTypeId()))
// {
// EDGE_ERROR << " Face " << cpNeighborFace1 << " has no Plane" << EDGE_ENDL;
// }
// if (!cpSurface1.isOfType(Plane.getClassTypeId()))
// {
// EDGE_ERROR << " Face " << cpNeighborFace2 << " has no Plane" << EDGE_ENDL;
// }
//
// Plane pPlane1 = (Plane)cpSurface1;
// GmPlane gmPlane1 = pPlane1.getEquation();
// Plane pPlane2 = (Plane)cpSurface2;
// GmPlane gmPlane2 = pPlane2.getEquation();
//
//
// // --------------------------------------------------------------------
// // calc intersection straight of the two planes
// // --------------------------------------------------------------------
//
// boolean intesectionSuccess = false;
// GmStraight interesctionStraight = new GmStraight();
// boolean intersectionWorked = plane_plane_int(gmPlane1, gmPlane2, interesctionStraight, intesectionSuccess);
// if (!intesectionSuccess)
// {
// EDGE_WARNING << "Something went wrong in the plane_plane_intersection : intesectionSuccess = false" << EDGE_ENDL;
// }
// if (!intersectionWorked)
// {
// EDGE_WARNING << "Something went wrong in the plane_plane_intersection : intersectionWorked = false" << EDGE_ENDL;
// }
// UnitVector3d intersetionDirection = interesctionStraight.getDir();
//
// // --------------------------------------------------------------------
// // create new pNewVertex
// // --------------------------------------------------------------------
//
// Point3d pointCopy = pVertexToSplit.getPositionOnGeometry();
// Vertex pNewVertex = new Vertex(pointCopy);
//
// // --------------------------------------------------------------------
// // create new Edge and connect pVertex with pNewVertex ( use straight from above)
// // --------------------------------------------------------------------
//
// GmStraight gmStraight = new GmStraight(pVertexToSplit.getPositionOnGeometry(), intersetionDirection);
// Straight straight = new Straight(gmStraight); // TODO : simply use method getIntersectionStraight
// Edge pNewEdge = new Edge(straight, Topology.FORWARD, pVertexToSplit, pNewVertex);
//
//
// // --------------------------------------------------------------------
// / get the two neighbor loops
// // --------------------------------------------------------------------
//
// Loop pLoop1 = (Loop)cpNeighborFace1.getLoop();
// Loop pLoop2 = (Loop)cpNeighborFace2.getLoop();
//
// // --------------------------------------------------------------------
// // get the corresponding coEdges of the loops where the new Coedges should be placed
// // --------------------------------------------------------------------
//
// CoEdge pPrevCoEdge1;
// CoEdge pNextCoEdge1;
// CoEdge pPrevCoEdge2;
// CoEdge pNextCoEdge2;
// findPrevAndNextCoEdge(pVertexToSplit, pLoop1, pPrevCoEdge1, pNextCoEdge1);
// findPrevAndNextCoEdge(pVertexToSplit, pLoop2, pPrevCoEdge2, pNextCoEdge2);
//
//
// // --------------------------------------------------------------------
// // set new relationship between pNewVertex and edges
// // --------------------------------------------------------------------
// for (Edge pTempEdge : getAllEdgesForVertex(pVertexToSplit))
// {
// // the two edges of the sweepface will get the pNewVertex (all other edges with that vertex will keep it)
// if (pTempEdge == pNewEdge)
// {
// // pTempEdge is pNewEdge -> ignore
// continue;
// }
//
// if (edgesToElongateList.contains(pTempEdge))
// {
// // pTempEdge is elongated edge -> ignore
// continue;
// }
//
// if (pTempEdge.getStartVertex() == pVertexToSplit)
// {
//
// ((Edge)pTempEdge).setStartVertex(pNewVertex);
// }
// else if (pTempEdge.getEndVertex() == pVertexToSplit)
// {
// ((Edge)pTempEdge).setEndVertex(pNewVertex);
// }
// else
// {
// EDGE_ERROR << " edge does not contain Vertex" << EDGE_ENDL;
// }
// }
//
// // --------------------------------------------------------------------
// // create coEdges; the two faces are the corresponding faces to the coEdges
// // --------------------------------------------------------------------
//
// CoEdge pNewCoEdge1;
// if (pPrevCoEdge1.getEndVertex() == pNewEdge.getStartVertex() || pPrevCoEdge1.getStartVertex() == pNewEdge.getEndVertex())
// {
// pNewCoEdge1 = new CoEdge(pNewEdge, Topology.FORWARD);
// }
// else if (pPrevCoEdge1.getEndVertex() == pNewEdge.getEndVertex() || pPrevCoEdge1.getStartVertex() == pNewEdge.getStartVertex())
// {
// pNewCoEdge1 = new CoEdge(pNewEdge, Topology.REVERSED);
// }
// setGeometryForCoEdge(pNewCoEdge1);
//
// CoEdge pNewCoEdge2;
// if (pPrevCoEdge2.getEndVertex() == pNewEdge.getStartVertex() || pPrevCoEdge2.getStartVertex() == pNewEdge.getEndVertex())
// {
// pNewCoEdge2 = new CoEdge(pNewEdge, Topology.FORWARD);
// }
// else if (pPrevCoEdge2.getEndVertex() == pNewEdge.getEndVertex() || pPrevCoEdge2.getStartVertex() == pNewEdge.getStartVertex())
// {
// pNewCoEdge2 = new CoEdge(pNewEdge, Topology.REVERSED);
// }
// setGeometryForCoEdge(pNewCoEdge2);
//
// pNewCoEdge1.setPartner(pNewCoEdge2);
// pNewCoEdge2.setPartner(pNewCoEdge1);
// pNewCoEdge1.setPrevious(pPrevCoEdge1);
// pNewCoEdge1.setNext(pNextCoEdge1);
// pNewCoEdge2.setPrevious(pPrevCoEdge2);
// pNewCoEdge2.setNext(pNextCoEdge2);
//
// pLoop1.addCoEdge(pNewCoEdge1);
// pLoop2.addCoEdge(pNewCoEdge2);
//
// if (mPrintInfo)
// {
// System.out.print(" SPLIT VERTEX (PULL) ");
// System.out.print(pVertexToSplit);
// System.out.print(" NEW VERTEX : ");
// System.out.print(pNewVertex);
// System.out.print(" NEW EDGE : ");
// System.out.print(pNewEdge);
// System.out.println();
// }
//
// // save changes in Trackchanges
// mpBuilding.getTrackChanges().addNewVertex(pNewVertex);
// for (Face cpFace : getFacesForVertex(pNewVertex))
// {
// mpBuilding.getTrackChanges().changeFace((Face)cpFace);
// }
// return pNewVertex;
//
// }
}
}
\ No newline at end of file
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Dies ist die Gitlab-Instanz des Transferportals der Hochschule für Technik Stuttgart. Hier geht es zurück zum Portal