converted ink addpoints to not use sampling. needs addPoints() to be filled in.

1 files changed, 60 insertions, 56 deletions

diff --git a/src/client/views/InkStrokeProperties.ts b/src/client/views/InkStrokeProperties.ts
index 2073497b9..03946bb60 100644
--- a/src/client/views/InkStrokeProperties.ts
+++ b/src/client/views/InkStrokeProperties.ts
@@ -1,3 +1,4 @@
+import { Bezier } from "bezier-js";
 import { action, computed, observable, reaction } from "mobx";
 import { Doc, Field, Opt } from "../../fields/Doc";
 import { Document } from "../../fields/documentSchemas";
@@ -70,67 +71,70 @@ export class InkStrokeProperties {
 
     /**
      * Adds a new control point to the ink instance when editing its format.
-     * @param index The index of the new point.
+     * @param t T-Value of new control point
+     * @param i index of first control point of segment being split
      * @param control The list of all control points of the ink.
      */
     @undoBatch
     @action
-    addPoints = (x: number, y: number, points: InkData, index: number, controls: { X: number, Y: number }[]) => {
-        this.applyFunction((doc: Doc, ink: InkData) => {
-            const newControl = { X: x, Y: y };
-            const newPoints: InkData = [];
-            let [counter, start, end] = [0, 0, 0];
-            for (let k = 0; k < points.length; k++) {
-                if (end === 0) {
-                    controls.forEach((control) => {
-                        if (control.X === points[k].X && control.Y === points[k].Y) {
-                            if (k < index) {
-                                counter++;
-                                start = k;
-                            } else if (k > index) {
-                                end = k;
-                            }
-                        }
-                    });
-                }
-            }
-            if (end === 0) end = points.length - 1;
-            // Index of new control point with regards to the ink data.
-            const newIndex = Math.floor(counter / 2) * 4 + 2;
-            // Creating new ink data with the new control point and handle points inputted.
-            for (let i = 0; i < ink.length; i++) {
-                if (i === newIndex) {
-                    const [handleA, handleB] = this.getNewHandlePoints(points.slice(start, index + 1), points.slice(index, end), newControl);
-                    newPoints.push(handleA, newControl, newControl, handleB);
-                    // Adjusting the magnitude of the left handle line of the right neighboring control point.
-                    const [rightControl, rightHandle] = [points[end], ink[i]];
-                    const scaledVector = this.getScaledHandlePoint(false, start, end, index, rightControl, rightHandle);
-                    rightHandle && newPoints.push({ X: rightControl.X - scaledVector.X, Y: rightControl.Y - scaledVector.Y });
-                } else if (i === newIndex - 1) {
-                    // Adjusting the magnitude of the right handle line of the left neighboring control point.
-                    const [leftControl, leftHandle] = [points[start], ink[i]];
-                    const scaledVector = this.getScaledHandlePoint(true, start, end, index, leftControl, leftHandle);
-                    leftHandle && newPoints.push({ X: leftControl.X - scaledVector.X, Y: leftControl.Y - scaledVector.Y });
-                } else {
-                    ink[i] && newPoints.push({ X: ink[i].X, Y: ink[i].Y });
-                }
+    addPoints = (t: number, i: number, controls: { X: number, Y: number }[]) => {
+        const array = [{ x: controls[i].X, y: controls[i].Y }, { x: controls[i + 1].X, y: controls[i + 1].Y }, { x: controls[i + 2].X, y: controls[i + 2].Y }, { x: controls[i + 3].X, y: controls[i + 3].Y }];
+        const newsegs = new Bezier(array).split(t);
+        // this.applyFunction((doc: Doc, ink: InkData) => {
+        //     const newControl = { X: x, Y: y };
+        //     const newPoints: InkData = [];
+        //     let [counter, start, end] = [0, 0, 0];
+        //     for (let k = 0; k < points.length; k++) {
+        //         if (end === 0) {
+        //             controls.forEach((control) => {
+        //                 if (control.X === points[k].X && control.Y === points[k].Y) {
+        //                     if (k < index) {
+        //                         counter++;
+        //                         start = k;
+        //                     } else if (k > index) {
+        //                         end = k;
+        //                     }
+        //                 }
+        //             });
+        //         }
+        //     }
+        //     if (end === 0) end = points.length - 1;
+        //     // Index of new control point with regards to the ink data.
+        //     const newIndex = Math.floor(counter / 2) * 4 + 2;
+        //     // Creating new ink data with the new control point and handle points inputted.
+        //     for (let i = 0; i < ink.length; i++) {
+        //         if (i === newIndex) {
+        //             const [handleA, handleB] = this.getNewHandlePoints(points.slice(start, index + 1), points.slice(index, end), newControl);
+        //             newPoints.push(handleA, newControl, newControl, handleB);
+        //             // Adjusting the magnitude of the left handle line of the right neighboring control point.
+        //             const [rightControl, rightHandle] = [points[end], ink[i]];
+        //             const scaledVector = this.getScaledHandlePoint(false, start, end, index, rightControl, rightHandle);
+        //             rightHandle && newPoints.push({ X: rightControl.X - scaledVector.X, Y: rightControl.Y - scaledVector.Y });
+        //         } else if (i === newIndex - 1) {
+        //             // Adjusting the magnitude of the right handle line of the left neighboring control point.
+        //             const [leftControl, leftHandle] = [points[start], ink[i]];
+        //             const scaledVector = this.getScaledHandlePoint(true, start, end, index, leftControl, leftHandle);
+        //             leftHandle && newPoints.push({ X: leftControl.X - scaledVector.X, Y: leftControl.Y - scaledVector.Y });
+        //         } else {
+        //             ink[i] && newPoints.push({ X: ink[i].X, Y: ink[i].Y });
+        //         }
 
-            }
-            let brokenIndices = Cast(doc.brokenInkIndices, listSpec("number"));
-            // Updating the indices of the control points whose handle tangency has been broken.
-            if (brokenIndices) {
-                brokenIndices = new List(brokenIndices.map((control) => {
-                    if (control >= newIndex) {
-                        return control + 4;
-                    } else {
-                        return control;
-                    }
-                }));
-            }
-            doc.brokenInkIndices = brokenIndices;
-            this._currentPoint = -1;
-            return newPoints;
-        });
+        //     }
+        //     let brokenIndices = Cast(doc.brokenInkIndices, listSpec("number"));
+        //     // Updating the indices of the control points whose handle tangency has been broken.
+        //     if (brokenIndices) {
+        //         brokenIndices = new List(brokenIndices.map((control) => {
+        //             if (control >= newIndex) {
+        //                 return control + 4;
+        //             } else {
+        //                 return control;
+        //             }
+        //         }));
+        //     }
+        //     doc.brokenInkIndices = brokenIndices;
+        //     this._currentPoint = -1;
+        //     return newPoints;
+        // });
     }
 
     /**