Merge branch '71-fix-mesh-topology' into 'master'

Resolve "Fix mesh topology"

Closes #71

See merge request grp-fidentis/analyst2!71

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/CornerTable.java

@@ -205,10 +205,10 @@ public class CornerTable {
     }
 
     /**
-     * returns corners of specific vertex
+     * Returns corners (rows of the corner table) in which the given vertex appears.
      *
      * @param vertexIndex index of vertex
-     * @return list of rows of corner table
+     * @return list of rows in which the given vertex appears.
      */
     public List<CornerTableRow> getCornersByVertexIndex(int vertexIndex) {
         return vertexToRow.get(vertexIndex).stream()
@@ -242,4 +242,14 @@ public class CornerTable {
         }
         return indexes;
     }
+    
+    
+    @Override
+    public String toString() {
+        String ret = "";
+        for (int i = 0; i < getSize(); i++) {
+            ret += getRow(i).getVertexIndex() + " | " + getRow(i).getOppositeCornerIndex() + System.lineSeparator();
+        }
+        return ret;
+    }
 }

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/CornerTableRow.java

@@ -6,18 +6,26 @@ package cz.fidentis.analyst.mesh.core;
  * @author Matej Lukes
  */
 public class CornerTableRow {
-    private int oppositeCornerIndex;
+    
+    /**
+     * Index to the corner (corner table row) with a vertex on the opposite triangle
+     */
+    private int oppositeCornerRow;
+    
+    /**
+     * Index to the shared array of vertices
+     */
     private int vertexIndex;
 
     /**
      * Constructor of a row in corner
      *
-     * @param vertexIndex         index of associated vertex in MashFacet
-     * @param oppositeCornerIndex index of the opposite corner, -1 if there is no opposite corner
+     * @param vertexIndex       index of associated vertex in MashFacet
+     * @param oppositeCornerRow index of the opposite corner, -1 if there is no opposite corner
      */
-    public CornerTableRow(int vertexIndex, int oppositeCornerIndex) {
+    public CornerTableRow(int vertexIndex, int oppositeCornerRow) {
         this.vertexIndex = vertexIndex;
-        this.oppositeCornerIndex = oppositeCornerIndex;
+        this.oppositeCornerRow = oppositeCornerRow;
     }
 
     /**
@@ -27,7 +35,7 @@ public class CornerTableRow {
      */
     public CornerTableRow(CornerTableRow cornerTableRow) {
         this.vertexIndex = cornerTableRow.getVertexIndex();
-        this.oppositeCornerIndex = cornerTableRow.getOppositeCornerIndex();
+        this.oppositeCornerRow = cornerTableRow.getOppositeCornerIndex();
     }
 
     /**
@@ -43,7 +51,7 @@ public class CornerTableRow {
      * @return index of opposite corner
      */
     public int getOppositeCornerIndex() {
-        return oppositeCornerIndex;
+        return oppositeCornerRow;
     }
 
     /**
@@ -52,6 +60,6 @@ public class CornerTableRow {
      * @param index index of the opposite corner in corner table
      */
     public void setOppositeCornerIndex(int index) {
-        this.oppositeCornerIndex = index;
+        this.oppositeCornerRow = index;
     }
 }

MeshModel/src/main/java/cz/fidentis/analyst/mesh/core/TriangleFan.java

+package cz.fidentis.analyst.mesh.core;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 1-ring neighborhood of a given mesh point. The neighborhood consists of 
+ * a ring of vertices forming triangles around the given central point.
+ * 
+ * @author Radek Oslejsek
+ */
+public class TriangleFan {
+    
+    private final List<Integer> vertices = new LinkedList<>();
+    private final List<Integer> triangles = new LinkedList<>();
+    
+    public TriangleFan(MeshFacet facet, int vert) {
+        if (facet == null) {
+            throw new IllegalArgumentException("facet");
+        }
+        
+        //System.out.println(facet.getVertices());
+        
+        CornerTable ct = facet.getCornerTable();
+        
+        int vertRow = getVertexRow(ct, vert);
+        //System.out.println("DDD " + vert + " " + vertRow + " " + ct.getRow(vertRow).getVertexIndex());
+        if (vertRow == -1) {
+            throw new IllegalArgumentException("vert");
+        }
+        
+        computeOneRingData(ct, vertRow, vertices, triangles);
+    }
+    
+    public boolean isEnclosed() {
+        return Objects.equals(vertices.get(0), vertices.get(vertices.size()-1));
+    }
+    
+    public boolean isBoundery() {
+        return !isEnclosed();
+    }
+    
+    public List<Integer> getVertices() {
+        return Collections.unmodifiableList(vertices);
+    }
+    
+    public List<Integer> getTriangles() {
+        return Collections.unmodifiableList(triangles);
+    }
+    
+    private void computeOneRingData(CornerTable ct, int vertRow, List<Integer> vertices, List<Integer> triangles) {
+        //System.out.println(ct);
+        //System.out.println("AAA " + ct.getRow(vertRow).getVertexIndex());
+        int ringVertRow = ct.getIndexOfNextCornerInFace(vertRow);
+        while (true) {
+            //System.out.println("BBB " + ct.getRow(ringVertRow).getVertexIndex());
+            vertices.add(ct.getRow(ringVertRow).getVertexIndex());
+            if (vertices.size() > 1 && isEnclosed()) {
+                return; // the ring is closed; we are done
+            }
+            //System.out.println("CCC " + ct.getRow(ct.getIndexOfNextCornerInFace(ringVertRow)).getVertexIndex());
+            ringVertRow = ct.getIndexOfOppositeCorner(ct.getIndexOfNextCornerInFace(ringVertRow));
+            if (ringVertRow == -1) {
+                break; // we reached an open end
+            }
+            //System.out.println("DDD " + ct.getRow(ringVertRow).getVertexIndex());
+            triangles.add(ct.getIndexOfFace(ringVertRow));
+        }
+        
+        ringVertRow = ct.getIndexOfPreviousCornerInFace(vertRow);
+        while (true) {
+            vertices.add(0, ct.getRow(ringVertRow).getVertexIndex());
+            if (vertices.size() > 1 && isEnclosed()) {
+                return; // the ring is closed; we are done
+            }
+            ringVertRow = ct.getIndexOfOppositeCorner(ct.getIndexOfPreviousCornerInFace(ringVertRow));
+            if (ringVertRow == -1) {
+                break; // we reached an open end
+            }
+            triangles.add(ct.getIndexOfFace(ringVertRow));
+        }
+    }
+    
+    private int getVertexRow(CornerTable cornerTable, int vert) {
+        for (int i = 0; i < cornerTable.getSize(); i++) {
+            if (cornerTable.getRow(i).getVertexIndex() == vert) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    
+}

MeshModel/src/main/java/cz/fidentis/analyst/mesh/io/MeshObjLoader.java

@@ -85,9 +85,9 @@ public class MeshObjLoader {
     }
 
     /**
-     * Parse OBJMesh into MeshFacet containig corner table data
+     * Parse OBJMesh into MeshFacet containing corner table data
      * @param model Model is needed in future. It's holding data pools
-     * @param mesh Mesh to parse. It corespond to our MeshFacet
+     * @param mesh Mesh to parse. It correspond to our MeshFacet
      * @return Returns complete facet
      * @throws IOException Data are corrupted
      */
@@ -117,8 +117,9 @@ public class MeshObjLoader {
     private static void processFace(OBJModel model, OBJFace face, MeshFacet meshFacet,
                     Map<MeshPoint, Integer> vertices, Map<Edge, Integer> edges) throws IOException {
         List<MeshPoint> trianglePoints = parseFaceToTriangle(model, face);
-        List<Integer> vertexIndicies = new ArrayList();
-
+        
+        int actRow = meshFacet.getCornerTable().getSize();
+        
         // This cycle adds integer indices of new mesh points and add them to CornerTable
         for (MeshPoint vertex : trianglePoints) {
             Integer vertIndex = vertices.get(vertex);
@@ -128,18 +129,17 @@ public class MeshObjLoader {
                 meshFacet.addVertex(vertex);
                 vertIndex = newIndex;
             }
-            vertexIndicies.add(vertIndex);
             CornerTableRow cornerTableRow = new CornerTableRow(vertIndex, -1);
             meshFacet.getCornerTable().addRow(cornerTableRow);
         }
 
         List<Edge> triangleEdges = new ArrayList();
         triangleEdges.add(new Edge(trianglePoints.get(0).getPosition(),
-                    trianglePoints.get(1).getPosition(), vertexIndicies.get(2)));
+                    trianglePoints.get(1).getPosition(), actRow + 2));
         triangleEdges.add(new Edge(trianglePoints.get(1).getPosition(),
-                    trianglePoints.get(2).getPosition(), vertexIndicies.get(0)));
+                    trianglePoints.get(2).getPosition(), actRow + 0));
         triangleEdges.add(new Edge(trianglePoints.get(2).getPosition(),
-                    trianglePoints.get(0).getPosition(), vertexIndicies.get(1)));
+                    trianglePoints.get(0).getPosition(), actRow + 1));
 
         for (Edge e : triangleEdges) {
             // We are processing edge which we already found