1 files changed, 93 insertions, 31 deletions

diff --git a/platform_tools/android/apps/skar_java/src/main/java/com/google/skar/SkARFingerPainting.java b/platform_tools/android/apps/skar_java/src/main/java/com/google/skar/SkARFingerPainting.java
index c93a900f58..e28037dc33 100644
--- a/platform_tools/android/apps/skar_java/src/main/java/com/google/skar/SkARFingerPainting.java
+++ b/platform_tools/android/apps/skar_java/src/main/java/com/google/skar/SkARFingerPainting.java
@@ -1,16 +1,25 @@
 package com.google.skar;
 
+import android.graphics.Color;
 import android.graphics.Path;
 import android.graphics.PointF;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 import java.util.ArrayList;
 
 public class SkARFingerPainting {
     // Points obtained by touching the screen. The first point is always brough to (0,0).
     // All subsequent points are translated by the same amount.
-    public ArrayList<PointF> points = new ArrayList<>();
-
-    public Path path = new Path();
+    private ArrayList<PointF> points = new ArrayList<>();
+    private ArrayList<Integer> jumpPoints = new ArrayList<>();
+    private Map<Integer, Integer> indexColors = new HashMap<>();
+    private Map<Path, Integer> pathColors = new HashMap<>();
+    private ArrayList<Path> paths = new ArrayList<>();
+    private int color = Color.RED;
 
     // Previous point added to the path. This points belongs to the path in local space.
     public PointF previousPoint;
@@ -34,49 +43,87 @@ public class SkARFingerPainting {
     }
 
     // Adds another point to the path in Local space
-    public void addPoint(PointF p) {
+    public void addPoint(PointF p, boolean jumpPoint) {
         points.add(p);
+        if (jumpPoint) {
+            Log.i("Jumped!", Integer.toString(points.size() - 1));
+            jumpPoints.add(points.size() - 1);
+            indexColors.put(points.size() - 1, color);
+        }
         previousPoint = p;
     }
 
     // Used to build a path before rendering it
     public void buildPath() {
-        if (points.size() < 1) {
+        paths = new ArrayList<>();
+        if (points.size() <= 1) {
             return;
         }
 
-        path = new Path();
+
         if (isSmooth) {
-            // If less than 3 points, than draw a line between the two points
-            if (points.size() <= 2 && points.size() > 0) {
-                path.moveTo(points.get(0).x, points.get(0).y);
-                path.lineTo(points.get(1).x, points.get(1).y);
-            } else if (points.size() >= 3){
-                // Else, essentially run deCasteljau
-                path.moveTo(points.get(0).x, points.get(0).y);
-                PointF mid = new PointF((points.get(0).x + points.get(1).x) / 2,
-                                        (points.get(0).y + points.get(1).y) / 2);
-                path.lineTo(mid.x, mid.y);
-
-                for (int i = 1; i < points.size() - 1; i++) {
-                    PointF p1 = points.get(i);
-                    PointF p2 = points.get(i + 1);
-                    PointF midP = new PointF((p1.x + p2.x) / 2,(p1.y + p2.y) / 2);
-                    path.quadTo(p1.x, p1.y, midP.x, midP.y);
-                }
-
-                path.lineTo(points.get(points.size() - 1).x, points.get(points.size() - 1).y);
+            int start = 0;
+            for (int j = 1; j < jumpPoints.size(); j++) {
+
+                int finish = jumpPoints.get(j);
+                buildSmoothFromTo(start, finish);
+                start = finish;
             }
+
+            buildSmoothFromTo(start, points.size());
         } else {
-            path.moveTo(points.get(0).x, points.get(0).y);
-            for (int i = 1; i < points.size(); i++) {
-                path.lineTo(points.get(i).x, points.get(i).y);
+
+            int start = 0;
+            for (int j = 1; j < jumpPoints.size(); j++) {
+                int finish = jumpPoints.get(j);
+                buildRoughFromTo(start, finish);
+                start = finish;
             }
+
+            buildRoughFromTo(start, points.size());
+        }
+    }
+
+    private void buildRoughFromTo(int start, int finish) {
+        Path p = new Path();
+        int c = indexColors.get(start);
+        p.moveTo(points.get(start).x, points.get(start).y);
+        for (int i = start + 1; i < finish; i++) {
+            p.lineTo(points.get(i).x, points.get(i).y);
         }
+        paths.add(p);
+        pathColors.put(p, c);
+    }
+
+    private void buildSmoothFromTo(int start, int finish) {
+        Path p = new Path();
+        int c = indexColors.get(start);
+        int nbPts = finish - start;
+        // If less than 3 points, than draw a line between the two points
+        if (nbPts <= 2 && nbPts > 1) {
+            p.moveTo(points.get(start).x, points.get(start).y);
+            p.lineTo(points.get(start + 1).x, points.get(start + 1).y);
+        } else if (nbPts >= 3){
+            // Else, essentially run deCasteljau
+            p.moveTo(points.get(start).x, points.get(start).y);
+            PointF mid = new PointF((points.get(start).x + points.get(start + 1).x) / 2,
+                                    (points.get(start).y + points.get(start + 1).y) / 2);
+            p.lineTo(mid.x, mid.y);
+
+            for (int i = start + 1; i < finish - 1; i++) {
+                PointF p1 = points.get(i);
+                PointF p2 = points.get(i + 1);
+                p.quadTo(p1.x, p1.y, (p1.x + p2.x) / 2, (p1.y + p2.y) / 2);
+            }
+
+            p.lineTo(points.get(finish - 1).x, points.get(finish - 1).y);
+        }
+        paths.add(p);
+        pathColors.put(p, c);
     }
 
     public boolean isEmpty() {
-        return path.isEmpty();
+        return points.isEmpty();
     }
 
     public float[] getModelMatrix() {
@@ -87,8 +134,23 @@ public class SkARFingerPainting {
         modelMatrix = m;
     }
 
+    public void setColor(int color) {
+        this.color = color;
+    }
+
+    public int getPathColor(Path p) {
+        return pathColors.get(p);
+    }
+
+    public ArrayList<Path> getPaths() {
+        return paths;
+    }
+
     public void reset() {
-        points = new ArrayList<>();
-        path = new Path();
+        points.clear();
+        jumpPoints.clear();
+        paths.clear();
+        pathColors.clear();
+        indexColors.clear();
     }
 }