Singnificantly improved efficiency by caching re-used data

Comparison/src/main/java/cz/fidentis/analyst/symmetry/ApproxSymmetryPlane.java

@@ -47,47 +47,31 @@ public class ApproxSymmetryPlane extends Plane implements Comparable<ApproxSymme
     }
     
     private void setNormAndDist(MeshFacet facet, SignificantPoints sigPoints, Config config, int i, int j) {
-        double sigCurvI = sigPoints.getCurvature(i);
-        double sigCurvJ = sigPoints.getCurvature(j);
         int sigPointI = sigPoints.getVertexIndex(i);
         int sigPointJ = sigPoints.getVertexIndex(j);
-        
+        MeshPoint meshPointI = facet.getVertex(sigPointI);
+        MeshPoint meshPointJ = facet.getVertex(sigPointJ);
+                
         double minRatio = config.getMinCurvRatio();
         double maxRatio = 1.0 / minRatio;
-        double ratioIJ = sigCurvI / sigCurvJ; 
+        double ratioIJ = sigPoints.getCachedCurRatio(i, j);
         if (ratioIJ < minRatio || ratioIJ > maxRatio) {
             throw new UnsupportedOperationException();
         }
                 
-        MeshPoint meshPointI = facet.getVertex(sigPointI);
-        MeshPoint meshPointJ = facet.getVertex(sigPointJ);
-                
         Vector3d p1 = new Vector3d(meshPointI.getPosition());
         Vector3d p2 = new Vector3d(meshPointJ.getPosition());
-                        
-        Vector3d avrg = new Vector3d(p1);
-        avrg.add(p2);
-        avrg.scale(0.5);
-                        
         Vector3d normal = new Vector3d(p1);
         normal.sub(p2);
         normal.normalize(); 
-                        
-        double d = -(normal.x * avrg.x) - (normal.y * avrg.y) - (normal.z * avrg.z);
-                       
-        Vector3d ni = new Vector3d(meshPointI.getNormal());
-        Vector3d nj = new Vector3d(meshPointI.getNormal());
-        ni.normalize();
-        nj.normalize();
-
-        Vector3d normVec = new Vector3d(ni);
-        normVec.sub(nj);
-        normVec.normalize();
-        double normCos = normVec.dot(normal);
-
+        
+        double normCos = sigPoints.getCachedNormCosVec(i, j).dot(normal);
         if (Math.abs(normCos) < config.getMinNormAngleCos()) {
             throw new UnsupportedOperationException();
         }
+        
+        Vector3d avrg = sigPoints.getCachedAvgPos(i, j);
+        double d = -(normal.x * avrg.x) - (normal.y * avrg.y) - (normal.z * avrg.z);
 
         setNormal(normal);
         setDistance(d);
@@ -102,9 +86,7 @@ public class ApproxSymmetryPlane extends Plane implements Comparable<ApproxSymme
      * @param maxDist Distance limit
      */
     private void computeVotes(MeshFacet facet, SignificantPoints sigPoints, Config config, double maxDist) {
-        
         normalize();
-        
         Vector3d normal = getNormal();
         double d = getDistance();
         double maxCurvRatio = 1.0 / config.getMinCurvRatio();
@@ -119,42 +101,32 @@ public class ApproxSymmetryPlane extends Plane implements Comparable<ApproxSymme
                     continue;
                 }
                 
-                double ratioIJ = sigPoints.getCurvature(i) / sigPoints.getCurvature(j);
+                double ratioIJ = sigPoints.getCachedCurRatio(i, j);
                 if (ratioIJ < config.getMinCurvRatio() || ratioIJ > maxCurvRatio) {
                     continue;
                 }
                 
+                double normCos = sigPoints.getCachedNormCosVec(i, j).dot(normal);
+                if (Math.abs(normCos) < config.getMinNormAngleCos()) {
+                    continue;
+                }
+                
                 int sigPointI = sigPoints.getVertexIndex(i);
                 int sigPointJ = sigPoints.getVertexIndex(j);
+                MeshPoint meshPointI = facet.getVertex(sigPointI);
+                MeshPoint meshPointJ = facet.getVertex(sigPointJ);
                     
-                Vector3d vec = new Vector3d(facet.getVertices().get(sigPointI).getPosition());
-                vec.sub(facet.getVertices().get(sigPointJ).getPosition());
+                Vector3d vec = new Vector3d(meshPointI.getPosition());
+                vec.sub(meshPointJ.getPosition());
                 vec.normalize();
                 double cos = vec.dot(normal);
-                    
-                Vector3d ni = new Vector3d(facet.getVertex(sigPointI).getNormal());
-                Vector3d nj = new Vector3d(facet.getVertex(sigPointJ).getNormal());
-                ni.normalize();
-                nj.normalize();
-                    
-                Vector3d normVec = ni;
-                normVec.sub(nj);
-                normVec.normalize();
-                double normCos = normVec.dot(normal);
- 
-                if (Math.abs(cos) < config.getMinAngleCos() || Math.abs(normCos) < config.getMinNormAngleCos()) {
+                if (Math.abs(cos) < config.getMinAngleCos()) {
                     continue;
                 }
                 
-                Vector3d avrg = new Vector3d(facet.getVertices().get(sigPointI).getPosition());
-                Vector3d aux = new Vector3d(facet.getVertices().get(sigPointJ).getPosition());
-                avrg.add(aux);
-                avrg.scale(0.5);
-                        
+                Vector3d avrg = sigPoints.getCachedAvgPos(i, j);
                 double dist = normal.x * avrg.x + normal.y * avrg.y + normal.z * avrg.z + d;
-                        
                 dist = Math.abs(dist);
-                        
                 if (dist <= maxDist) {                 
                     votes++;  
                 }   

Comparison/src/main/java/cz/fidentis/analyst/symmetry/SignificantPoints.java

 package cz.fidentis.analyst.symmetry;
 
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshPoint;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import javax.vecmath.Vector3d;
 
 /**
  * Finds and stores the top X points with the most significant curvarure.
@@ -12,7 +15,14 @@ import java.util.List;
  */
 public class SignificantPoints {
 
-    private List<VertCurvature> significantPoints;
+    private final List<VertCurvature> significantPoints;
+    
+    private List<List<Vector3d>> normCosVecCache;
+    
+    private List<List<Vector3d>> avgPosCache;
+    
+    private List<List<Double>> curRatioCache;
+    
     
     /**
      * Constructor.
@@ -20,15 +30,81 @@ public class SignificantPoints {
      * @param max Maximal number of points
      */
     public SignificantPoints(List<Double> curvatures, int max) {
-        significantPoints = new ArrayList<>(curvatures.size());
+        List<VertCurvature> sp = new ArrayList<>(curvatures.size());
         for (int i = 0; i < curvatures.size(); i++) { 
-            significantPoints.add(new VertCurvature(i, curvatures.get(i)));
+            sp.add(new VertCurvature(i, curvatures.get(i)));
+        }
+        
+        Collections.sort(sp);
+        if (max < sp.size()) {
+            significantPoints = new ArrayList<>(sp.subList(0, max));
+        } else {
+            significantPoints = sp;
+        }
+        
+    }
+    
+    public void cacheData(MeshFacet facet) {
+        if (normCosVecCache != null) {
+            return;
         }
         
-        Collections.sort(significantPoints);
-        if (max < significantPoints.size()) {
-            significantPoints = new ArrayList<>(significantPoints.subList(0, max));
+        normCosVecCache = new ArrayList<>(significantPoints.size());
+        avgPosCache = new ArrayList<>(significantPoints.size());
+        curRatioCache = new ArrayList<>(significantPoints.size());
+        
+        for (int i = 0; i < significantPoints.size(); i++) {
+            List<Vector3d> cosArray = new ArrayList<>(significantPoints.size());
+            normCosVecCache.add(cosArray);
+            
+            List<Vector3d> posArray = new ArrayList<>(significantPoints.size());
+            avgPosCache.add(posArray);
+            
+            List<Double> curArray = new ArrayList<>(significantPoints.size());
+            curRatioCache.add(curArray);
+            
+            for (int j = 0; j < significantPoints.size(); j++) {
+                MeshPoint meshPointI = facet.getVertex(significantPoints.get(i).vertIndex);
+                MeshPoint meshPointJ = facet.getVertex(significantPoints.get(j).vertIndex);
+                
+                Vector3d ni = new Vector3d(meshPointI.getNormal());
+                Vector3d nj = new Vector3d(meshPointJ.getNormal());
+                ni.normalize();
+                nj.normalize();
+                ni.sub(nj);
+                ni.normalize();
+                cosArray.add(ni);
+                
+                Vector3d avrg = new Vector3d(meshPointI.getPosition());
+                Vector3d aux = new Vector3d(meshPointJ.getPosition());
+                avrg.add(aux);
+                avrg.scale(0.5);
+                posArray.add(avrg);
+                
+                curArray.add(significantPoints.get(i).curvature / significantPoints.get(j).curvature);
+            }
+        }
+    }
+    
+    public Vector3d getCachedNormCosVec(int i, int j) {
+        if (normCosVecCache == null || i >= normCosVecCache.size() || i >= normCosVecCache.size() || i < 0 || j < 0) {
+            return null;
+        }
+        return normCosVecCache.get(i).get(j);
+    }
+    
+    public Vector3d getCachedAvgPos(int i, int j) {
+        if (avgPosCache == null || i >= avgPosCache.size() || i >= avgPosCache.size() || i < 0 || j < 0) {
+            return null;
+        }
+        return avgPosCache.get(i).get(j);
+    }
+    
+    public double getCachedCurRatio(int i, int j) {
+        if (curRatioCache == null || i >= curRatioCache.size() || i >= curRatioCache.size() || i < 0 || j < 0) {
+            return Double.NaN;
         }
+        return curRatioCache.get(i).get(j);
     }
     
     /**

Comparison/src/main/java/cz/fidentis/analyst/symmetry/SymmetryEstimator.java

@@ -90,6 +90,7 @@ public class SymmetryEstimator {
         
         curvatures = calculateCurvatures(facet, maxCurvatureAlg);
         final SignificantPoints sigPoints = new SignificantPoints(curvatures, config.getSignificantPointCount());
+        sigPoints.cacheData(facet);
         
         // Initiate structure for concurrent computation:
         ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());