From 7fed1940bb4f3a333cef92fd51787a29e6dd787b Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 10 Apr 2012 14:18:02 -0700
Subject: compute and store local coordinates for all anchor points and their
 control handles separately, AND more hit testing with local coordinates

---
 js/lib/geom/sub-path.js | 165 ++++++++++++++++++++++++++++++++++++++++--------
 js/tools/PenTool.js     |  76 +++++++++++-----------
 2 files changed, 175 insertions(+), 66 deletions(-)

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index 33bcfc9a..64f27bd3 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -57,7 +57,7 @@ var GLSubpath = function GLSubpath() {
     this._LocalPoints = [];             //polyline representation of this curve in canvas space
     this._LocalBBoxMin = [0,0,0];       //bbox min point of _LocalPoints
     this._LocalBBoxMax = [0,0,0];       //bbox max point of _LocalPoints
-
+    this._AnchorLocalCoords = [];       //local coords for all the anchor points , stored as a triplet of 3D vectors (prev, curr, next, in order)
     this._UnprojectedAnchors = [];
 
     //initially set the _dirty bit so we will construct samples
@@ -66,6 +66,9 @@ var GLSubpath = function GLSubpath() {
     //initially set the local dirty bit so we will construct local coordinates
     this._isLocalDirty = true;
 
+    //initially set the local dirty bit for the anchors so we will construct local coordinates
+    this._isAnchorLocalDirty = true;
+    
     //whether or not to use the canvas drawing to stroke/fill
     this._useCanvasDrawing = true;
 
@@ -92,8 +95,8 @@ var GLSubpath = function GLSubpath() {
 
     //tool that owns this subpath
     this._drawingTool = null;
-    this._planeMat = null;
-    this._planeMatInv = null;
+    this._planeMat =  Matrix.I(4);
+    this._planeMatInv = Matrix.I(4);
     this._planeCenter = null;
     this._dragPlane = null;
 
@@ -498,6 +501,27 @@ GLSubpath.prototype.insertAnchorAtParameter = function(index, param) {
     this._dirty = true;
 };
 
+GLSubpath.prototype._checkIntersectionWithSampleLocalCoord = function(startIndex, endIndex, point, radius){
+    //check whether the point is within the radius distance from the curve represented as a polyline in _samples
+    //return the parametric distance along the curve if there is an intersection, else return null
+    //will assume that the BBox test is performed outside this function
+    if (endIndex<startIndex){
+        //go from startIndex to the end of the samples
+        endIndex = this._LocalPoints.length;
+    }
+    for (var i=startIndex; i<endIndex-1; i++){
+        var seg0 = this._LocalPoints[i].slice(0);
+        var j=i+1;
+        var seg1 = this._LocalPoints[j].slice(0);
+        var distToSegment = MathUtils.distPointToSegment(point, seg0, seg1);
+        if (distToSegment<=radius){
+            var paramDistance = MathUtils.paramPointProjectionOnSegment(point, seg0, seg1); //TODO Optimize! this function was called in distPointToSegment above
+            return this._sampleParam[i] + (this._sampleParam[j] - this._sampleParam[i])*paramDistance;
+        }
+    }
+    return null;
+};
+
 GLSubpath.prototype._checkIntersectionWithSamples = function(startIndex, endIndex, point, radius){
     //check whether the point is within the radius distance from the curve represented as a polyline in _samples
     //return the parametric distance along the curve if there is an intersection, else return null
@@ -622,23 +646,24 @@ GLSubpath.prototype._isWithinBoundingBox = function(point, ctrlPts, radius) {
 
 GLSubpath.prototype._checkAnchorIntersection = function(pickX, pickY, pickZ, radSq, anchorIndex, minDistance, useLocal) {
     //if we are asked to use the local coordinate and the local coordinate for this anchor exists
-    if (useLocal && this._anchorSampleIndex.length>anchorIndex && this._LocalPoints.length > this._anchorSampleIndex[anchorIndex]) {
-        var localCoord = this._LocalPoints[this._anchorSampleIndex[anchorIndex]]
-        var distSq = VecUtils.vecDistSq(3, [pickX, pickY, pickZ], localCoord);
+    if (useLocal && this._AnchorLocalCoords.length > anchorIndex) {//this._anchorSampleIndex.length>anchorIndex && this._LocalPoints.length > this._anchorSampleIndex[anchorIndex]) {
+        //var localCoord = this._LocalPoints[this._anchorSampleIndex[anchorIndex]];
+        var anchorLocalCoord = this._AnchorLocalCoords[anchorIndex];
+        var distSq = VecUtils.vecDistSq(3, [pickX, pickY, pickZ], anchorLocalCoord[1]);
         //check the anchor point
         if (distSq < radSq && distSq<minDistance) {
             return this.SEL_ANCHOR;
         }
-        /*
+
         //check the prev. and next of the selected anchor point
-        distSq = this._Anchors[anchorIndex].getPrevDistanceSq(pickX, pickY, pickZ);
+        distSq = VecUtils.vecDistSq(3, [pickX, pickY, pickZ], anchorLocalCoord[0]);
         if (distSq<radSq && distSq<minDistance){
             return this.SEL_PREV;
         }
-        distSq = this._Anchors[anchorIndex].getNextDistanceSq(pickX, pickY, pickZ);
+        distSq = VecUtils.vecDistSq(3, [pickX, pickY, pickZ], anchorLocalCoord[2]);
         if (distSq<radSq && distSq<minDistance){
             return this.SEL_NEXT;
-        }*/
+        }
         return this.SEL_NONE;
     }
 
@@ -694,6 +719,42 @@ GLSubpath.prototype.isWithinBBox = function(x,y,z) {
     return true;
 }
 
+//pick the path location closest to the input pick point (in local coord)
+GLSubpath.prototype.pathSamplesLocalHitTest = function(pickX, pickY, pickZ, radius){
+    var numAnchors = this._AnchorLocalCoords.length;
+    var selAnchorIndex = -1;
+    var retParam = null;
+    var radSq = radius * radius;
+    var minDistance = Infinity;
+
+    //first check if the input location is within the bounding box
+    var numSegments = this._isClosed ? numAnchors : numAnchors-1;
+    var currAnchor = this._AnchorLocalCoords[0];
+    var nextAnchor=null;
+    for (var i = 0; i < numSegments; i++) {
+        var nextIndex = (i+1)%numAnchors;
+        nextAnchor = this._AnchorLocalCoords[nextIndex];
+        //check if the point is close to the bezier segment between anchor i and anchor nextIndex
+        var controlPoints = [currAnchor[1].slice(0),
+            currAnchor[2].slice(0),
+            nextAnchor[0].slice(0),
+            nextAnchor[1].slice(0)];
+        var point = [pickX, pickY, pickZ];
+        if (this._isWithinBoundingBox(point, controlPoints, radius)) {
+            //var intersectParam = this._checkIntersection(controlPoints, 0.0, 1.0, point, radius);
+            var intersectParam = this._checkIntersectionWithSampleLocalCoord(this._anchorSampleIndex[i], this._anchorSampleIndex[nextIndex], point, radius);
+            if (intersectParam){
+                selAnchorIndex=i;
+                retParam = intersectParam-i; //make the retParam go from 0 to 1
+                break;
+            }
+        }
+        currAnchor = nextAnchor;
+    }//for every anchor i
+    return [selAnchorIndex,retParam];
+
+};
+
 //pick the path point closest to the specified location, return null if some anchor point (or its handles) is within radius, else return the parameter distance
 GLSubpath.prototype.pathHitTest = function (pickX, pickY, pickZ, radius) {
     var numAnchors = this._Anchors.length;
@@ -755,7 +816,6 @@ GLSubpath.prototype.pathHitTest = function (pickX, pickY, pickZ, radius) {
                 if (this._isWithinBoundingBox(point, controlPoints, radius)) {
                     //var intersectParam = this._checkIntersection(controlPoints, 0.0, 1.0, point, radius);
                     var intersectParam = this._checkIntersectionWithSamples(this._anchorSampleIndex[i], this._anchorSampleIndex[nextIndex], point, radius);
-                    console.log("intersectParam:"+intersectParam);
                     if (intersectParam){
                         selAnchorIndex=i;
                         retParam = intersectParam-i; //make the retParam go from 0 to 1
@@ -1145,13 +1205,24 @@ GLSubpath.prototype._unprojectPt = function(pt, pespectiveDist) {
 
 //return the local coord. of the anchor at the specified index, null if the anchor does not have a local coord yet
 GLSubpath.prototype.getAnchorLocalCoord = function(index){
-    if (this._isDirty){
+    if (this._dirty){
         this.createSamples();
     }
     if (this._isLocalDirty){
         this.buildLocalCoord();
     }
-    if (index<0 || index>= this._Anchors.length || index>=this._anchorSampleIndex.length){
+    if (index<0 || index>= this._Anchors.length){
+        return null;
+    }
+
+    if (index>= this._AnchorLocalCoords.length || this._isAnchorLocalDirty){
+        this._isAnchorLocalDirty = true;
+        this.buildAnchorLocalCoord();
+    }
+
+    return this._AnchorLocalCoords[index];
+    /*
+    if (index>=this._anchorSampleIndex.length){
         return null;
     }
     var anchorSampleIndex = this._anchorSampleIndex[index];
@@ -1160,6 +1231,55 @@ GLSubpath.prototype.getAnchorLocalCoord = function(index){
     }
     var localCoord = this._LocalPoints[anchorSampleIndex].slice(0);
     return localCoord;
+    */
+};
+
+GLSubpath.prototype.buildAnchorLocalCoord = function()
+{
+    if (!this._isAnchorLocalDirty){
+        return; //nothing to do
+    }
+    var ViewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+    var SnapManager = require("js/helper-classes/3D/snap-manager").SnapManager;
+
+    var widthAdjustment = -SnapManager.getStageWidth()*0.5;
+    var heightAdjustment = -SnapManager.getStageHeight()*0.5;
+
+    var drawingCanvas = this.getCanvas();
+    if (!drawingCanvas){
+        drawingCanvas = ViewUtils.getStageElement();
+    }
+    var localToStageWorldMat = ViewUtils.getLocalToStageWorldMatrix(drawingCanvas, true, false);
+    var stageWorldToLocalMat = glmat4.inverse(localToStageWorldMat, []);
+    var numAnchors = this._Anchors.length;
+    this._AnchorLocalCoords = [];
+    var i=0, currAnchor, prevLocalCoord, currLocalCoord, nextLocalCoord;
+    for (i=0;i<numAnchors;i++){
+        //get the local coordinate of this anchor point
+        currAnchor = this._Anchors[i];
+        //convert all three positions assoc. with this anchor from stage world to local coord
+        prevLocalCoord = MathUtils.transformAndDivideHomogeneousPoint([
+            currAnchor.getPrevX()+widthAdjustment,
+            currAnchor.getPrevY()+heightAdjustment,
+            currAnchor.getPrevZ()],
+            stageWorldToLocalMat);
+
+        currLocalCoord = MathUtils.transformAndDivideHomogeneousPoint([
+            currAnchor.getPosX()+widthAdjustment,
+            currAnchor.getPosY()+heightAdjustment,
+            currAnchor.getPosZ()],
+            stageWorldToLocalMat);
+
+        nextLocalCoord = MathUtils.transformAndDivideHomogeneousPoint([
+            currAnchor.getNextX()+widthAdjustment,
+            currAnchor.getNextY()+heightAdjustment,
+            currAnchor.getNextZ()],
+            stageWorldToLocalMat);
+
+        this._AnchorLocalCoords.push([prevLocalCoord, currLocalCoord, nextLocalCoord]);
+    } //for every anchor index i
+
+    this._isAnchorLocalDirty=false;
 };
 
 //buildLocalCoord
@@ -1218,6 +1338,9 @@ GLSubpath.prototype.buildLocalCoord = function () {
     this._LocalBBoxMax[0]+= halfwidth; this._LocalBBoxMin[0]+= halfwidth;
     this._LocalBBoxMax[1]+= halfheight; this._LocalBBoxMin[1]+= halfheight;
 
+    //set the dirty bit for the local coords of the anchors, so those local coords will be re-calculated
+    this._isAnchorLocalDirty = true;
+
     this._isLocalDirty = false;
 }
 
@@ -1299,19 +1422,6 @@ GLSubpath.prototype.createSamples = function () {
     this._dirty = false;
 };
 
-GLSubpath.prototype.getLocalBBoxMidInStageWorld = function() {
-    var ViewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
-    //compute the plane center as the midpoint of the local bbox converted to stage world space
-    var bboxWidth=0, bboxHeight=0;
-    var bboxMid=[0,0,0];
-    bboxWidth = this._LocalBBoxMax[0] - this._LocalBBoxMin[0];
-    bboxHeight = this._LocalBBoxMax[1] - this._LocalBBoxMin[1];
-    bboxMid = [0.5 * (this._LocalBBoxMax[0] + this._LocalBBoxMin[0]), 0.5 * (this._LocalBBoxMax[1] + this._LocalBBoxMin[1]), 0.5 * (this._LocalBBoxMax[2] + this._LocalBBoxMin[2])];
-    var planeCenter =  ViewUtils.localToStageWorld(bboxMid, this._canvas);
-    planeCenter[0]+=400; planeCenter[1]+=300; //todo replace these lines with the correct call for the offset
-    console.log("PEN: local midPt: "+ bboxMid +", stageWorld midPt: "+planeCenter);
-    return planeCenter;
-}
 
 GLSubpath.prototype._computeLocalBoundingBox = function() {
     this._LocalBBoxMin = [Infinity, Infinity, Infinity];
@@ -1636,7 +1746,8 @@ GLSubpath.prototype.importJSON = function(jo) {
     this._strokeColor = jo.strokeColor;
     this._fillColor = jo.fillColor;
 
-    this._isDirty = true;
+    this._dirty = true;
+    this._isAnchorLocalDirty = true;
 };
 
 GLSubpath.prototype.import = function( importStr ) {
diff --git a/js/tools/PenTool.js b/js/tools/PenTool.js
index 6c016cab..cd15b36b 100755
--- a/js/tools/PenTool.js
+++ b/js/tools/PenTool.js
@@ -57,7 +57,7 @@ exports.PenTool = Montage.create(ShapeTool, {
     _isPickedEndPointInSelectPathMode: {value: false, writable: true},
 
     //when the user wants to place a selected anchor point on top of another point, this is the target where the point will be placed
-    _snapTarget: { value: null, writable: true },
+    _snapTargetIndex: { value: -1, writable: true },
 
     //whether or not we're using webgl for drawing
     _useWebGL: {value: false, writable: false },
@@ -210,7 +210,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                         //setting the selection mode to NONE will effectively add a new anchor point at the click location and also give us snapping
                         whichPoint = this._selectedSubpath.SEL_NONE;
                         //set the snap target in case the mouse move handler doesn't get called
-                        this._snapTarget = this._selectedSubpath.getAnchor(0);
+                        this._snapTargetIndex = 0;
                     }
                 }
                 //check if the clicked location is close to prev and next of the selected anchor point..if so select that anchor, set mode to PREV or NEXT and do nothing else
@@ -240,7 +240,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                             this._penCanvas = null;
                             this._penPlaneMat = null;
                             this._dragPlane = null;
-                            this._snapTarget = null;
+                            this._snapTargetIndex = -1;
                             this._selectedSubpath = new SubPath();
                             this._isNewPath = true;
                         }
@@ -355,7 +355,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                     }
 
                     //snapping...check if the new location of the anchor point is close to another anchor point
-                    this._snapTarget = null;
+                    this._snapTargetIndex = -1;
                     var numAnchors = this._selectedSubpath.getNumAnchors();
                     for (var i = 0; i < numAnchors; i++) {
                         //check if the selected anchor is close to any other anchors
@@ -365,7 +365,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                         var distSq = currAnchor.getDistanceSq(selX, selY, selZ);
                         if (distSq < this._PICK_POINT_RADIUS * this._PICK_POINT_RADIUS) {
                             //set the snap target to the location of the first close-enough anchor
-                            this._snapTarget = currAnchor;
+                            this._snapTargetIndex = i;
                             break;
                         }
                     }
@@ -413,7 +413,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                         this.application.ninja.stage.drawingCanvas.style.cursor = cursor;
                     } else {
                         //detect if the current mouse position will hit the path (such that clicking here will insert a new anchor)
-                        var pathHitTestData = this._selectedSubpath.pathHitTest(currMousePos[0], currMousePos[1], currMousePos[2], this._PICK_POINT_RADIUS*0.5);
+                        var pathHitTestData = this._selectedSubpath.pathSamplesLocalHitTest(localMousePos[0], localMousePos[1], localMousePos[2], this._PICK_POINT_RADIUS*0.5);
                         if (pathHitTestData[0]!==-1){
                             //change the cursor
                             var cursor = "url('images/cursors/penCursors/Pen_plus.png') 5 1, default";
@@ -543,11 +543,6 @@ exports.PenTool = Montage.create(ShapeTool, {
                     h = Math.round(h);
                     ElementMediator.setProperty(canvasArray, "width", [w+"px"], "Changing", "penTool");//canvas.width = w;
                     ElementMediator.setProperty(canvasArray, "height", [h+"px"], "Changing", "penTool");//canvas.height = h;
-
-                    //var bboxMid = this._selectedSubpath.getLocalBBoxMidInStageWorld();
-                    //left = Math.round(bboxMid[0] - 0.5 * w);
-                    //top = Math.round(bboxMid[1] - 0.5 * h);
-
                     ElementMediator.setProperty(canvasArray, "left", [left+"px"],"Changing", "penTool");//DocumentControllerModule.DocumentController.SetElementStyle(canvas, "left", parseInt(left) + "px");
                     ElementMediator.setProperty(canvasArray, "top", [top + "px"],"Changing", "penTool");//DocumentControllerModule.DocumentController.SetElementStyle(canvas, "top", parseInt(top) + "px");
 
@@ -590,9 +585,10 @@ exports.PenTool = Montage.create(ShapeTool, {
             }
 
             //snapping...if there was a snapTarget and a selected anchor, move the anchor to the snap target
-            if (this._snapTarget !== null && this._selectedSubpath && this._selectedSubpath.getSelectedAnchorIndex() !== -1) {
+            if (this._snapTargetIndex !== -1 && this._selectedSubpath && this._selectedSubpath.getSelectedAnchorIndex() !== -1) {
                 var selAnchor = this._selectedSubpath.getAnchor(this._selectedSubpath.getSelectedAnchorIndex());
-                selAnchor.setPos(this._snapTarget.getPosX(), this._snapTarget.getPosY(), this._snapTarget.getPosZ());
+                var snapAnchor = this._selectedSubpath.getAnchor(this._snapTargetIndex);
+                selAnchor.setPos(snapAnchor.getPosX(), snapAnchor.getPosY(), snapAnchor.getPosZ());
                 this._selectedSubpath.makeDirty();
 
                 //if the first or last anchor point were snapped for an open path, check if the first and last anchor point are at the same position
@@ -600,7 +596,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                     var lastAnchorIndex = this._selectedSubpath.getNumAnchors() - 1;
                     var firstAnchor = this._selectedSubpath.getAnchor(0);
                     var lastAnchor = this._selectedSubpath.getAnchor(lastAnchorIndex);
-                    if ((this._selectedSubpath.getSelectedAnchorIndex() === 0 && this._snapTarget === lastAnchor) || (this._selectedSubpath.getSelectedAnchorIndex() === lastAnchorIndex && this._snapTarget === firstAnchor)) {
+                    if ((this._selectedSubpath.getSelectedAnchorIndex() === 0 && this._snapTargetIndex === lastAnchorIndex) || (this._selectedSubpath.getSelectedAnchorIndex() === lastAnchorIndex && this._snapTargetIndex === 0)) {
                         this._selectedSubpath.setIsClosed(true);
                         //set the prev of the first anchor to the be prev of the last anchor
                         firstAnchor.setPrevPos(lastAnchor.getPrevX(), lastAnchor.getPrevY(), lastAnchor.getPrevZ());
@@ -616,7 +612,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                     }
                 }
             }
-            this._snapTarget = null;
+            this._snapTargetIndex = -1;
 
             var drawData = this.getDrawingData();
             if (drawData) {
@@ -699,7 +695,7 @@ exports.PenTool = Montage.create(ShapeTool, {
             //close the current subpath and reset the pen tool
             this._penCanvas = null;
             this._penPlaneMat = null;
-            this._snapTarget = null;
+            this._snapTargetIndex = -1;
             this._selectedSubpath = null;
             this.application.ninja.stage.clearDrawingCanvas();
         }
@@ -954,17 +950,21 @@ exports.PenTool = Montage.create(ShapeTool, {
                 throw ("null drawing context in Pentool::DrawSelectedSubpathAnchors");
             ctx.save();
 
-            var widthAdjustment = -snapManager.getStageWidth()*0.5;
-            var heightAdjustment = -snapManager.getStageHeight()*0.5;
-
             var drawingCanvas = subpath.getCanvas();
             if (!drawingCanvas){
                 drawingCanvas = ViewUtils.getStageElement();
             }
             var localToGlobalMat = ViewUtils.getLocalToGlobalMatrix(drawingCanvas);
+
+            /*
+            var widthAdjustment = -snapManager.getStageWidth()*0.5;
+            var heightAdjustment = -snapManager.getStageHeight()*0.5;
             var localToStageWorldMat = ViewUtils.getLocalToStageWorldMatrix(drawingCanvas, true, false);
             var stageWorldToLocalMat = glmat4.inverse(localToStageWorldMat, []);
+            */
 
+            //build the local coord. for each anchor point (appropriate dirty bit checked in function)
+            subpath.buildAnchorLocalCoord();
             
             //display circles and squares near all control points
             ctx.fillStyle = "#FFFFFF";
@@ -975,11 +975,14 @@ exports.PenTool = Montage.create(ShapeTool, {
             var px=0,py=0;
             var localCoord = null;
             var sp=[0,0,0];
-            var currAnchor = null;
+            var currAnchor = null, currAnchorLocalCoord=null;
             for (var i = 0; i < numAnchors; i++) {
-                currAnchor = subpath.getAnchor(i);
-                localCoord = MathUtils.transformAndDivideHomogeneousPoint([currAnchor.getPosX()+widthAdjustment, currAnchor.getPosY()+heightAdjustment, currAnchor.getPosZ()], stageWorldToLocalMat); //convert from stage world to local coord
-                sp = MathUtils.transformAndDivideHomogeneousPoint(localCoord,localToGlobalMat); //convert from local coord to global (screen) coord
+
+                //currAnchor = subpath.getAnchor(i);
+                //localCoord = MathUtils.transformAndDivideHomogeneousPoint([currAnchor.getPosX()+widthAdjustment, currAnchor.getPosY()+heightAdjustment, currAnchor.getPosZ()], stageWorldToLocalMat); //convert from stage world to local coord
+                //sp = MathUtils.transformAndDivideHomogeneousPoint(localCoord,localToGlobalMat); //convert from local coord to global (screen) coord
+                currAnchorLocalCoord = subpath.getAnchorLocalCoord(i);
+                sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[1],localToGlobalMat); //convert from local coord to global (screen) coord
                 px = sp[0]; py=sp[1];
 
                 ctx.beginPath();
@@ -995,9 +998,8 @@ exports.PenTool = Montage.create(ShapeTool, {
             //display the hovered over anchor point
             ctx.lineWidth = 2;
             if (this._hoveredAnchorIndex>=0 && this._hoveredAnchorIndex<numAnchors) {
-                currAnchor = subpath.getAnchor(this._hoveredAnchorIndex);
-                localCoord = MathUtils.transformAndDivideHomogeneousPoint([currAnchor.getPosX()+widthAdjustment, currAnchor.getPosY()+heightAdjustment, currAnchor.getPosZ()], stageWorldToLocalMat); //convert from stage world to local coord
-                sp = MathUtils.transformAndDivideHomogeneousPoint(localCoord,localToGlobalMat);
+                currAnchorLocalCoord = subpath.getAnchorLocalCoord(this._hoveredAnchorIndex);
+                sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[1],localToGlobalMat); //convert from local coord to global (screen) coord
                 px = sp[0]; py=sp[1];
 
                 ctx.beginPath();
@@ -1022,17 +1024,14 @@ exports.PenTool = Montage.create(ShapeTool, {
                 var selAnchor = this._selectedSubpath.getAnchor(this._selectedSubpath.getSelectedAnchorIndex());
                 var whichPoint = this._selectedSubpath.getSelectedMode(); //which of the selected handles to highlight
 
-                //compute the screen (global) coord. of the selected anchor
-                localCoord = MathUtils.transformAndDivideHomogeneousPoint([selAnchor.getPosX()+widthAdjustment, selAnchor.getPosY()+heightAdjustment, selAnchor.getPosZ()], stageWorldToLocalMat); //convert from stage world to local coord
-                sp = MathUtils.transformAndDivideHomogeneousPoint(localCoord,localToGlobalMat);
+                currAnchorLocalCoord = subpath.getAnchorLocalCoord(this._selectedSubpath.getSelectedAnchorIndex());
+                sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[1],localToGlobalMat); //convert from local coord to global (screen) coord
                 var posX = sp[0]; var posY=sp[1];
 
-                //compute the screen (global) coord. of the selected anchor prev and next points
-                var prevLocalCoord = MathUtils.transformAndDivideHomogeneousPoint([selAnchor.getPrevX()+widthAdjustment, selAnchor.getPrevY()+heightAdjustment, selAnchor.getPrevZ()], stageWorldToLocalMat);
-                sp = MathUtils.transformAndDivideHomogeneousPoint(prevLocalCoord, localToGlobalMat);
+                sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[0],localToGlobalMat); //convert from local coord to global (screen) coord
                 var prevX = sp[0]; var prevY=sp[1];
-                var nextLocalCoord = MathUtils.transformAndDivideHomogeneousPoint([selAnchor.getNextX()+widthAdjustment, selAnchor.getNextY()+heightAdjustment, selAnchor.getNextZ()], stageWorldToLocalMat);
-                sp = MathUtils.transformAndDivideHomogeneousPoint(nextLocalCoord, localToGlobalMat);
+
+                sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[2],localToGlobalMat); //convert from local coord to global (screen) coord
                 var nextX = sp[0]; var nextY=sp[1];
 
                 //line from prev to anchor
@@ -1087,10 +1086,9 @@ exports.PenTool = Montage.create(ShapeTool, {
                 ctx.stroke();
 
                 //display the snap target if it isn't null
-                if (this._snapTarget) {
-                    localCoord = MathUtils.transformAndDivideHomogeneousPoint([this._snapTarget.getPosX()+widthAdjustment, this._snapTarget.getPosY()+heightAdjustment, this._snapTarget.getPosZ()], stageWorldToLocalMat); //convert from stage world to local coord
-                    sp = MathUtils.transformAndDivideHomogeneousPoint(localCoord,localToGlobalMat);
-                    px = sp[0]; py =sp[1];
+                if (this._snapTargetIndex>=0) {
+                    currAnchorLocalCoord = subpath.getAnchorLocalCoord(this._snapTargetIndex);
+                    sp = MathUtils.transformAndDivideHomogeneousPoint(currAnchorLocalCoord[1],localToGlobalMat); //convert from local coord to global (screen) coordpx = sp[0]; py =sp[1];
 
                     ctx.lineWidth = 2;
                     ctx.strokeStyle = "red";
@@ -1166,7 +1164,7 @@ exports.PenTool = Montage.create(ShapeTool, {
                 this._selectedSubpath = null;
                 this._penCanvas = null;
                 this._penPlaneMat = null;
-                this._snapTarget = null;
+                this._snapTargetIndex = -1;
                 defaultEventManager.removeEventListener("resetPenTool", this, false);
                 this.application.ninja.elementMediator.deleteDelegate = null;
             } //if the pen tool was de-selected
-- 
cgit v1.2.3