generalbgh/algorithms-for-computing-line-estimators
generalbgh
/
algorithms-for-computing-line-estimators
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

DCEL entfernt, angefangen die ersten Klassen zu kommentieren.

This commit is contained in:
Armin Wolf 2017-10-13 11:53:45 +02:00
parent 1ee749cc08
commit 274778b780
12 changed files with 197 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
LinearRegressionTool/src/main/java/App.java
View File

@ -1,3 +1,4 @@
import com.sun.java.swing.plaf.windows.WindowsLookAndFeel;
import model.Line;
import model.LineModel;
import nu.pattern.OpenCV;
@ -26,24 +27,6 @@ import static nu.pattern.OpenCV.loadShared;
*/
public class App {
private static void loadLibrary() {
try {
InputStream in = null;
File fileOut = null;
in = App.class.getResourceAsStream("/libs/x64/opencv_java2413.dll");
fileOut = File.createTempFile("tmp", ".dll");
OutputStream out = new FileOutputStream(fileOut);
IOUtils.copy(in, out);
in.close();
out.close();
System.load(fileOut.toString());
} catch (Exception e) {
throw new RuntimeException("Failed to load opencv native library", e);
}
}
private static void setUIFont(javax.swing.plaf.FontUIResource f) {
java.util.Enumeration<Object> keys = UIManager.getDefaults().keys();
while (keys.hasMoreElements()) {
@ -60,7 +43,9 @@ public class App {
"com.jtattoo.plaf.acryl.AcrylLookAndFeel",
"com.jtattoo.plaf.aero.AeroLookAndFeel",
"com.jtattoo.plaf.fast.FastLookAndFeel",
"com.jtattoo.plaf.graphite.GraphiteLookAndFeel"};
"com.jtattoo.plaf.graphite.GraphiteLookAndFeel",
"com.jtattoo.plaf.luna.LunaLookAndFeel",
"com.jtattoo.plaf.noire.NoireLookAndFeel"};
try {
UIManager.setLookAndFeel(laf[4]);
} catch (ClassNotFoundException e) {
@ -93,7 +78,7 @@ public class App {
if (chosen == "Normal"){
final Presenter presenter = new Presenter(new LineModel(), null);
SwingUtilities.invokeLater(() -> {
JFrame.setDefaultLookAndFeelDecorated(true);
//JFrame.setDefaultLookAndFeelDecorated(true);
MainFrame view = new MainFrame();
setLookAndFeel(view);
setUIFont(new javax.swing.plaf.FontUIResource(new Font("Verdana", Font.PLAIN, 12)));

154
LinearRegressionTool/src/main/java/model/DCEL/DoublyConnectedEdgeList.java
View File

@ -1,154 +0,0 @@
package model.DCEL;
import model.Point;
import java.util.LinkedList;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 30.05.2017.
*/
public class DoublyConnectedEdgeList {
private LinkedList<Node> nodes;
private LinkedList<Edge> edges;
private LinkedList<Face> faces;
public DoublyConnectedEdgeList() {
this.nodes = new LinkedList<>();
this.edges = new LinkedList<>();
this.faces = new LinkedList<>();
}
public Node createNode(Point point, String id) {
Node node = new Node();
node.setPoint(point);
node.setID(id);
return node;
}
public Edge createEdge(Node source, Node destination, String id) {
Edge edge = new Edge();
Edge twin = new Edge();
edge.setOrigin(source);
edge.setID(id);
edge.setTwin(twin);
twin.setOrigin(destination);
twin.setID("#" + id);
twin.setTwin(edge);
source.setIncidentEdge(edge);
destination.setIncidentEdge(twin);
return edge;
}
public Face createFace(Edge outerComponent, Edge innerComponent, String id) {
Face face = new Face(outerComponent, null);
face.setID(id);
Edge tempEdge;
if (outerComponent != null) {
tempEdge = outerComponent;
do {
tempEdge.setIncidentFace(face);
tempEdge = tempEdge.getNext();
} while (!tempEdge.equals(outerComponent));
}
if (innerComponent != null) {
LinkedList<Edge> componentlist;
componentlist = face.getInnerComponents();
componentlist.add(innerComponent);
tempEdge = innerComponent;
do {
tempEdge.setIncidentFace(face);
tempEdge = tempEdge.getNext();
} while (!tempEdge.equals(innerComponent));
}
return face;
}
public void createConnection(Edge edge, Edge succ) {
edge.setNext(succ);
succ.setPrev(edge);
edge.getTwin().setPrev(succ.getTwin());
succ.getTwin().setNext(edge.getTwin());
}
public LinkedList<Edge> getEdgesOfInnerComponents(Face face) {
LinkedList<Edge> list = new LinkedList();
LinkedList<Edge> innerComponents = face.getInnerComponents();
Edge it;
for (Edge e : innerComponents) {
it = e;
do {
list.add(it);
//System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
it = it.getNext();
} while (it != e);
}
return list;
}
public LinkedList<Edge> getEdgesOfOuterComponents(Face face) {
LinkedList<Edge> list = new LinkedList();
Edge it = face.getOuterComponent();
do {
list.add(it);
//System.out.println("Current Edge: "+it.getID()+"\tNext Edge: "+it.getNext().getID());
it = it.getNext();
} while (it != face.getOuterComponent());
return list;
}
public LinkedList<Edge> getConnectedEdges(Node node) {
Edge edge = node.getIncidentEdge();
LinkedList list = new LinkedList();
do {
list.add(edge);
edge = edge.getNext();
} while (node != edge.getOrigin());
return list;
}
public LinkedList<Node> getNodes() {
return nodes;
}
public void setNodes(LinkedList<Node> nodes) {
this.nodes = nodes;
}
public LinkedList<Edge> getEdges() {
return edges;
}
public void setEdges(LinkedList<Edge> edges) {
this.edges = edges;
}
public LinkedList<Face> getFaces() {
return faces;
}
public void setFaces(LinkedList<Face> faces) {
this.faces = faces;
}
}

117
LinearRegressionTool/src/main/java/model/DCEL/Edge.java
View File

@ -1,117 +0,0 @@
package model.DCEL;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 30.05.2017.
*/
public class Edge {
private Node origin;
private Edge twin;
private Face incidentFace;
private Edge next;
private Edge prev;
private String id;
public Edge() {
new Edge(null, null, null, null, null);
}
public Edge(Node origin, Edge twin, Edge next, Edge prev, Face incidentFace) {
this.origin = origin;
this.twin = twin;
this.next = next;
this.prev = prev;
this.incidentFace = incidentFace;
}
public Node getOrigin() {
return origin;
}
public void setOrigin(Node origin) {
this.origin = origin;
}
public Edge getTwin() {
return twin;
}
public void setTwin(Edge twin) {
this.twin = twin;
}
public Face getIncidentFace() {
return incidentFace;
}
public void setIncidentFace(Face incidentFace) {
this.incidentFace = incidentFace;
}
public Edge getNext() {
return next;
}
public void setNext(Edge next) {
this.next = next;
}
public Edge getPrev() {
return prev;
}
public void setPrev(Edge prev) {
this.prev = prev;
}
public boolean hasNext() {
if (getNext() == null) {
return false;
} else {
return true;
}
}
public Edge insertNode(Node node) {
Edge edge = new Edge();
Edge twin = new Edge();
edge.setOrigin(node);
edge.setNext(this.getNext());
edge.setPrev(this);
edge.setTwin(twin);
edge.setIncidentFace(this.getIncidentFace());
twin.setOrigin(this.getTwin().getOrigin());
twin.setPrev(this.getTwin().getPrev());
twin.setNext(this.getTwin());
twin.setTwin(edge);
twin.setIncidentFace(this.getTwin().getIncidentFace());
Node twinOrigin = this.getTwin().getOrigin();
twinOrigin.setIncidentEdge(twin);
node.setIncidentEdge(edge);
this.getTwin().setOrigin(node);
this.getTwin().getPrev().setNext(twin);
this.getNext().setPrev(edge);
this.setNext(edge);
this.getTwin().setPrev(twin);
return edge;
}
public String getID() {
return this.id;
}
public void setID(String id) {
this.id = id;
}
}

125
LinearRegressionTool/src/main/java/model/DCEL/Face.java
View File

@ -1,125 +0,0 @@
package model.DCEL;
import java.util.LinkedList;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 30.05.2017.
*/
public class Face {
private LinkedList<Edge> innerComponents;
private Edge outerComponent;
private String id;
public Face() {
this.outerComponent = null;
this.innerComponents = new LinkedList<>();
}
public Face(Edge outerComponent, LinkedList<Edge> innerComponents) {
this.outerComponent = outerComponent;
if (innerComponents != null) {
this.innerComponents = innerComponents;
} else {
this.innerComponents = new LinkedList<>();
}
}
public LinkedList<Edge> getInnerComponents() {
return innerComponents;
}
public void setInnerComponents(LinkedList<Edge> innerComponents) {
this.innerComponents = innerComponents;
}
public Edge getOuterComponent() {
return outerComponent;
}
public void setOuterComponent(Edge outerComponent) {
this.outerComponent = outerComponent;
}
public Face insertEdge(Edge edgeWithSameDestination, Edge edgeToMySource) {
if (edgeWithSameDestination.getIncidentFace().equals(this) || edgeToMySource.getIncidentFace()
.equals(this)) {
LinkedList<Edge> components = new LinkedList<Edge>();
for (Edge e : innerComponents) {
components.add(e);
}
Face face = new Face(getOuterComponent(), components);
Edge edge = new Edge();
Edge twin = new Edge();
edge.setOrigin(edgeWithSameDestination.getOrigin());
edge.setTwin(twin);
edge.setNext(edgeToMySource);
edge.setPrev(edgeWithSameDestination.getPrev());
twin.setOrigin(edgeToMySource.getOrigin());
twin.setTwin(edge);
twin.setNext(edgeWithSameDestination);
twin.setPrev(edgeToMySource.getPrev());
Edge tempEdge = edge.getNext();
Edge tempTwin = twin.getNext();
//kreis umlaufen um festzustellen welche fläche kleiner ist
while ((tempEdge.equals(edge) == false) && (tempTwin.equals(twin) == false)) {
tempEdge = tempEdge.getNext();
tempTwin = tempTwin.getNext();
}
if (tempEdge.equals(edge)) {
setOuterComponent(twin);
twin.setIncidentFace(this);
face.setOuterComponent(edge);
} else {
setOuterComponent(edge);
edge.setIncidentFace(this);
face.setOuterComponent(twin);
}
LinkedList<Edge> bla = new LinkedList<Edge>();
Edge iterEdge = face.getOuterComponent();
bla.add(face.getOuterComponent());
while (iterEdge.hasNext()) {
bla.add(iterEdge.getNext());
iterEdge = iterEdge.getNext();
}
for (Edge e : face.getInnerComponents()) {
iterEdge = e;
while (iterEdge.hasNext()) {
bla.add(iterEdge.getNext());
iterEdge = iterEdge.getNext();
}
}
for (Edge e : bla) {
e.setIncidentFace(face);
}
return face;
} else {
throw new IllegalArgumentException(
"Die angegebenen Kanten haben keinen zusammenhang mit der Fläche!");
}
}
public String getID() {
return this.id;
}
public void setID(String id) {
this.id = id;
}
}

50
LinearRegressionTool/src/main/java/model/DCEL/Node.java
View File

@ -1,50 +0,0 @@
package model.DCEL;
import model.Point;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 30.05.2017.
*/
public class Node {
private Point point;
private Edge incidentEdge;
private String id;
public Node() {
new Node(null, null);
}
public Node(Point point, Edge incidentEdge) {
this.point = point;
this.incidentEdge = incidentEdge;
}
public Point getPoint() {
return point;
}
public void setPoint(Point point) {
this.point = point;
}
public Edge getIncidentEdge() {
return incidentEdge;
}
public void setIncidentEdge(Edge incidentEdge) {
this.incidentEdge = incidentEdge;
}
public String getID() {
return this.id;
}
public void setID(String id) {
this.id = id;
}
}

28
LinearRegressionTool/src/main/java/model/Interval.java
View File

@ -13,38 +13,64 @@ public class Interval {
private double lower;
private Boolean activity;
/**
* Konstruktor
* @param lower untere Schranke
* @param upper obere Schranke
*/
public Interval(double lower, double upper) {
this.upper = upper;
this.lower = lower;
this.activity = true;
}
/**
* @return <code>true</code> falls das Intervall aktiv ist
*/
public Boolean getActivity() {
return activity;
}
/**
* @param isActive <code>true</code> falls das Intervall als aktiv gesetzt werden soll
*/
public void setActivity(Boolean isActive) {
this.activity = isActive;
}
/**
* @return obere Schranke des Intervalls
*/
public double getUpper() {
return upper;
}
/**
* @param upper obere Schranke des Intervalls
*/
public void setUpper(double upper) {
this.upper = upper;
}
/**
* @return untere Schranke des Intervalls
*/
public double getLower() {
return lower;
}
/**
* @param lower untere Schranke des Intervalls
*/
public void setLower(double lower) {
this.lower = lower;
}
/**
* Berechnet die Distanz zwischen der oberen und unteren Schranke
* @return Distanz
*/
public Double getDistance() {
return Math.abs(this.upper - this.lower);
}

63
LinearRegressionTool/src/main/java/model/Line.java
View File

@ -23,6 +23,12 @@ public class Line {
private String id;
/**
* Konstruktor
* @param m Steigung
* @param b y-Achsenabschnitt
* @param id id
*/
public Line(double m, double b, String id) {
this.m = m;
this.b = b;
@ -34,7 +40,11 @@ public class Line {
this.id = id;
}
/**
* Konstruktor
* @param m Steigung
* @param b y-Achsenabschnitt
*/
public Line(double m, double b) {
this.m = m;
this.b = b;
@ -45,6 +55,13 @@ public class Line {
this.y2 = ((MAX * 0.5) * m) + b;
}
/**
* Konstruktor
* @param x1 x-Koordiante des Startpunkts
* @param x2 x-Koordinate des Endpunkts
* @param y1 y-Koordinate des Startpunkts
* @param y2 y-Koordinate des Endpunkts
*/
public Line(double x1, double x2, double y1, double y2) {
this.x1 = x1;
this.x2 = x2;
@ -56,53 +73,97 @@ public class Line {
}
/**
* @return Steigung der Gerade
*/
public Double getM() {
return m;
}
/**
* @param m Steigung der Gerade
*/
public void setM(double m) {
this.m = m;
}
/**
* @return y-Achsenabschnitt der Gerade
*/
public Double getB() {
return b;
}
/**
* @param b y-Achsenabschnitt der Gerade
*/
public void setB(double b) {
this.b = b;
}
/**
* @return id der Gerade
*/
public String getId() {
return id;
}
/**
* @param id id der Gerade
*/
public void setId(String id) {
this.id = id;
}
/**
* @return x-Koordiante des Startpunkts
*/
public Double getX1() {
return x1;
}
/**
* @return x-Koordiante des Endpunkts
*/
public Double getX2() {
return x2;
}
/**
* @return y-Koordiante des Startpunkts
*/
public Double getY1() {
return y1;
}
/**
* @return y-Koordiante des Endpunkts
*/
public Double getY2() {
return y2;
}
/**
* Setzt die Koordianten des Segments. Aus dem Segment wird eine Gerade berechnet.
* @param x1 x-Koordiante des Startpunkts
* @param y1 y-Koordiante des Endpunkts
* @param x2 x-Koordinate des Startpunkts
* @param y2 y-Koordinte des Endpunkts
*/
public void setEndPoints(double x1, double y1, double x2, double y2) {
this.x1 = x1;
this.x2 = x2;
this.y1 = y1;
this.y2 = y2;
this.m = (y2 - y1) / (x2 - x1);
this.b = y2 - (x2 * m);
}
/**
* Vergleich einzelner Geradern
* @param other zu vergleichende Gerade
* @return <code>true</code> falls die Geraden Gleich sind
*/
public boolean equals(Line other) {
if (other.getM() == this.getM() && other.getB() == this.getB()) {
return true;

50
LinearRegressionTool/src/main/java/model/LineModel.java
View File

@ -19,6 +19,9 @@ public class LineModel {
private Double yMinimum;
private Double yMaximum;
/**
* Konstruktor
*/
public LineModel() {
nodes = new ArrayList<>();
lines = new LinkedList<>();
@ -30,62 +33,109 @@ public class LineModel {
}
/**
* Fügt einen Schnittpunkt zum Modell hinzu
* @param node Schnittpunkt
*/
public void addNode(Point node) {
this.nodes.add(node);
}
/**
* Fügt eine Gerade zu dem Modell hinzu
* @param line Gerade
*/
public void addLine(Line line) {
this.lines.add(line);
}
/**
* @return Liste der Schnittpunkte
*/
public ArrayList<Point> getNodes() {
return nodes;
}
/**
* @param nodes Liste der Schnittpunkte
*/
public void setNodes(ArrayList<Point> nodes) {
this.nodes = nodes;
}
/**
* @return Liste der Geraden
*/
public LinkedList<Line> getLines() {
return lines;
}
/**
* @param lines Liste der Geraden
*/
public void setLines(LinkedList<Line> lines) {
this.lines = lines;
}
/**
* @return Minimale x-Koordiante
*/
public Double getxMinimum() {
return xMinimum;
}
/**
* @param xMinimum Minimale x-Koordiante
*/
public void setxMinimum(Double xMinimum) {
this.xMinimum = xMinimum;
}
/**
* @return Maximale x-Koordiante
*/
public Double getxMaximum() {
return xMaximum;
}
/**
* @param xMaximum Maximale x-Koordiante
*/
public void setxMaximum(Double xMaximum) {
this.xMaximum = xMaximum;
}
/**
* @return Minimale y-Koordiante
*/
public Double getyMinimum() {
return yMinimum;
}
/**
* @param yMinimum Minimale y-Koordiante
*/
public void setyMinimum(Double yMinimum) {
this.yMinimum = yMinimum;
}
/**
* @return Maximale y-Koordiante
*/
public Double getyMaximum() {
return yMaximum;
}
/**
* @param yMaximum Maximale y-Koordiante
*/
public void setyMaximum(Double yMaximum) {
this.yMaximum = yMaximum;
}
/**
* Setzt die minimalen, maximalen x- und y-Koordinaten
*/
public void resetRanges() {
xMinimum = Double.MAX_VALUE;
xMaximum = Double.MIN_VALUE;

17
LinearRegressionTool/src/main/java/model/Pair.java
View File

@ -12,23 +12,40 @@ public class Pair {
private Integer p1;
private Integer p2;
/**
* Konstruktor
* @param p1 erstes Element des Tupels
* @param p2 zweites Element des Tupels
*/
public Pair(Integer p1, Integer p2) {
this.p1 = p1;
this.p2 = p2;
}
/**
* @return erstes Element des Tupels
*/
public Integer getP1() {
return p1;
}
/**
* @param p1 erstes Element des Tupels
*/
public void setP1(Integer p1) {
this.p1 = p1;
}
/**
* @return zweites Element des Tupels
*/
public Integer getP2() {
return p2;
}
/**
* @param p2 zweites Element des Tupels
*/
public void setP2(Integer p2) {
this.p2 = p2;
}

34
LinearRegressionTool/src/main/java/model/Point.java
View File

@ -13,29 +13,52 @@ public class Point implements Comparable<Point> {
private Double y;
private String id;
/**
* Konstruktor
* @param x x-Koordiante
* @param y y-Koordiante
*/
public Point(Double x, Double y) {
this.x = x;
this.y = y;
}
/**
* Konstruktor
* @param x x-Koordiante
* @param y y-Koordiante
* @param id id des Punkts
*/
public Point(Double x, Double y, String id) {
this.x = x;
this.y = y;
this.id = id;
}
/**
* @return x-Koordinate des Punkts
*/
public Double getX() {
return x;
}
/**
* @param x x-Koordinate des Punkts
*/
public void setX(Double x) {
this.x = x;
}
/**
* @return y-Koordinate des Punkts
*/
public Double getY() {
return y;
}
/**
* @param y y-Koordinate des Punkts
*/
public void setY(Double y) {
this.y = y;
}
@ -55,6 +78,11 @@ public class Point implements Comparable<Point> {
}
}
/**
* Vergleich zweier Punkte
* @param other zu vergleichernder Punkt
* @return <code>true</code> falls die Punkte gleich sind
*/
public boolean equals(Point other) {
if (other.getX() == this.getX() && other.getY() == this.getY()) {
return true;
@ -63,10 +91,16 @@ public class Point implements Comparable<Point> {
}
}
/**
* @return id des Punkts
*/
public String getId() {
return id;
}
/**
* @param id id des Punkts
*/
public void setId(String id) {
this.id = id;
}

3
LinearRegressionTool/src/main/java/view/MainFrame.java
View File

@ -284,7 +284,7 @@ public class MainFrame extends JFrame {
}
private void setDimensions() {
this.setSize(1600,1050);
this.setPreferredSize(new Dimension(1600,1050));
this.setMinimumSize(new Dimension(1024, 768));
this.setResizable(true);
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
@ -327,6 +327,7 @@ public class MainFrame extends JFrame {
importButton = new JButton();
generateButton = new JButton();
exportButton = new JButton();
pack();
}
private void setIcons() {

100
LinearRegressionTool/src/test/java/model/DoublyConnectedEdgeListTest.java
View File

@ -1,100 +0,0 @@
package model;
import model.DCEL.DoublyConnectedEdgeList;
import model.DCEL.Edge;
import model.DCEL.Face;
import model.DCEL.Node;
import org.junit.Before;
import org.junit.Test;
import java.util.LinkedList;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
* @Author: Armin Wolf
* @Email: a_wolf28@uni-muenster.de
* @Date: 30.05.2017.
*/
public class DoublyConnectedEdgeListTest {
private static DoublyConnectedEdgeList dcel;
private static Node v1, v2, v3, v4, v5;
private static Edge e1, e2, e3, e4, e5;
private static Face f1, f2;
@Before
public void setUp() throws Exception {
dcel = new DoublyConnectedEdgeList();
//initialisiere die TestKnoten im Graphen
v1 = dcel.createNode(new Point(2.5, 7.5), "v1");
v2 = dcel.createNode(new Point(2.5, 4.0), "v2");
v3 = dcel.createNode(new Point(6.5, 3.5), "v3");
v4 = dcel.createNode(new Point(8.5, 6.5), "v4");
v5 = dcel.createNode(new Point(6.0, 8.0), "v5");
//initialisere Kanten im Graph
e1 = dcel.createEdge(v1, v5, "e1");
e2 = dcel.createEdge(v5, v4, "e2");
e3 = dcel.createEdge(v4, v3, "e3");
e4 = dcel.createEdge(v3, v2, "e4");
e5 = dcel.createEdge(v2, v1, "e5");
dcel.createConnection(e1, e2);
dcel.createConnection(e2, e3);
dcel.createConnection(e3, e4);
dcel.createConnection(e4, e5);
dcel.createConnection(e5, e1);
//intialisiere die Flaechen
f1 = dcel.createFace(null, e1, "f1");
f2 = dcel.createFace(e1.getTwin(), null, "f2");
}
@Test
public void testInnerComponentsAccess() {
System.out.println("Test: testInnerComponentAccess();");
Edge[] expected = {e1, e2, e3, e4, e5};
LinkedList<Edge> list = dcel.getEdgesOfInnerComponents(f1);
assertArrayEquals(expected, list.toArray());
}
@Test
public void testOuterComponentsAccess() {
System.out.println("Test: testOuterComponentAccess();");
String[] expected = {"#e1", "#e5", "#e4", "#e3", "#e2"};
LinkedList<Edge> list = dcel.getEdgesOfOuterComponents(f2);
for (int i = 0; i < list.size(); i++) {
assertEquals(expected[i], list.get(i).getID());
}
}
@Test
public void testNodeEdgeAccess() {
System.out.println("Test: testNodeEdgeAccess();");
assertEquals(5, dcel.getConnectedEdges(v4).size());
}
@Test
public void testDCELAccess() {
System.out.println("Test: testDCELAccess();");
assertEquals(e1, e1.getTwin().getTwin());
assertEquals(e1, e1.getPrev().getNext());
assertEquals(e2.getID(), e1.getTwin().getPrev().getTwin().getID());
assertEquals(e1, e1.getNext().getNext().getNext().getNext().getNext());
assertEquals(e1.getTwin(), e1.getTwin().getNext().getNext().getNext().getNext().getNext());
}
}