path: root/js/lib/geom/sub-path.js

/* <copyright>
This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
(c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
</copyright> */


var VecUtils =      require("js/helper-classes/3D/vec-utils").VecUtils;
var CanvasController = require("js/controllers/elements/canvas-controller").CanvasController;
var GeomObj =       require("js/lib/geom/geom-obj").GeomObj;
var AnchorPoint =   require("js/lib/geom/anchor-point").AnchorPoint;
var MaterialsModel = require("js/models/materials-model").MaterialsModel;

///////////////////////////////////////////////////////////////////////
// Class GLSubpath
//      representation a sequence of cubic bezier curves.
//      Derived from class GeomObj
///////////////////////////////////////////////////////////////////////

var GLSubpath = function GLSubpath() {
    ///////////////////////////////////////////////////
    // Instance variables
    ///////////////////////////////////////////////////

    // NOTE:
    //  This class contains functionality to store piecewise cubic bezier paths.
    //  The coordinates of the paths are always in local, canvas space.
    //  That is, the Z coordinate can be ignored (for now), and the paths are essentially in 2D.
    //  All coordinates of the '_Samples' should lie within [0,0] and [width, height],
    //      where width and height refer to the dimensions of the canvas for this path.
    //  Whenever the the canvas dimensions change, the coordinates of the anchor points
    //      and _Samples must be re-computed.

    this._Anchors = [];
    this._BBoxMin = [0, 0, 0];
    this._BBoxMax = [0, 0, 0];
    this._canvasCenterLocalCoord = [0,0,0];

    this._isClosed = false;

    this._Samples = [];                 //polyline representation of this curve in canvas space
    this._sampleParam = [];             //parametric distance of samples, within [0, N], where N is # of Bezier curves (=# of anchor points if closed, =#anchor pts -1 if open)
    this._anchorSampleIndex = [];       //index within _Samples corresponding to anchor points

    //initially set the _dirty bit so we will re-construct _Anchors and _Samples
    this._dirty = true;

    //stroke information
    this._strokeWidth = 1.0;
    this._strokeColor = [0.4, 0.4, 0.4, 1.0];
    this._fillColor = [1.0, 1.0, 1.0, 0.0];
    this._DISPLAY_ANCHOR_RADIUS = 5;

    //drawing context
    this._world = null;
    this._canvas = null; //todo this might be unnecessary (but faster) since we can get it from the world
    
    //tool that owns this subpath
    this._drawingTool = null;

    //used to query what the user selected, OR-able for future extensions
    this.SEL_NONE = 0;          //nothing was selected
    this.SEL_ANCHOR = 1;        //anchor point was selected
    this.SEL_PREV = 2;          //previous handle of anchor point was selected
    this.SEL_NEXT = 4;          //next handle of anchor point was selected
    this.SEL_PATH = 8;          //the path itself was selected
    this._selectMode = this.SEL_NONE;
    this._selectedAnchorIndex = -1;

    this._SAMPLING_EPSILON = 0.5; //epsilon used for sampling the curve
}; //function GLSubpath ...class definition

GLSubpath.prototype = Object.create(GeomObj, {});

//buildBuffers
GLSubpath.prototype.buildBuffers = function () {
    //no need to do anything for now (no WebGL)
};

//buildColor returns the fillStyle or strokeStyle for the Canvas 2D context
GLSubpath.prototype.buildColor = function(ctx,          //the 2D rendering context (for creating gradients if necessary)
                                          ipColor,      //color string, also encodes whether there's a gradient and of what type
                                          w,            //width of the region of color
                                          h,            //height of the region of color
                                          lw)           //linewidth (i.e. stroke width/size)
{
    if (ipColor.gradientMode){
        var position, gradient, cs, inset; //vars used in gradient calculations
        inset = Math.ceil( lw ) - 0.5;
        inset=0;

        if(ipColor.gradientMode === "radial") {
            var ww = w - 2*lw,  hh = h - 2*lw;
            gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, Math.max(ww, hh)/2);
        } else {
            gradient = ctx.createLinearGradient(inset, h/2, w-inset, h/2);
        }
        var colors = ipColor.color;

        var len = colors.length;
        for(n=0; n<len; n++) {
            position = colors[n].position/100;
            cs = colors[n].value;
            gradient.addColorStop(position, "rgba(" + cs.r + "," + cs.g + "," + cs.b + "," + cs.a + ")");
        }
        return gradient;
    } else {
        var c = "rgba(" + 255*ipColor[0] + "," + 255*ipColor[1] + "," + 255*ipColor[2] + "," + ipColor[3] + ")";
        return c;
    }
};
//render
//  specify how to render the subpath in Canvas2D
GLSubpath.prototype.render = function () {
    // get the world
    var world = this.getWorld();
    if (!world)  throw( "null world in subpath render" );
    if (!this._canvas){
        //set the canvas by querying the world
        this._canvas = this.getWorld().getCanvas();
    }
    // get the context
    var ctx = world.get2DContext();
    if (!ctx)  throw ("null context in subpath render");

    var numAnchors = this.getNumAnchors();
    if (numAnchors === 0) {
        return; //nothing to do for empty paths
    }
    this.createSamples(false); //dirty bit checked in this function...will generate a polyline representation

    var numPoints = this._Samples.length;
    if (numPoints === 0){
        return; //nothing to do for empty paths
    }

    //figure the size of the area we will draw into
    var bboxWidth=0, bboxHeight=0;
    bboxWidth = this._BBoxMax[0] - this._BBoxMin[0];
    bboxHeight = this._BBoxMax[1] - this._BBoxMin[1];

    ctx.save();
    ctx.clearRect(0, 0, bboxWidth, bboxHeight);

    ctx.lineWidth = this._strokeWidth;
    ctx.strokeStyle = "black";

    //vars used for the gradient computation in buildColor
    var w = world.getViewportWidth(), h = world.getViewportHeight();

    if (this._strokeColor) {
        ctx.strokeStyle = this.buildColor(ctx, this._strokeColor, w,h, this._strokeWidth);
    }

    ctx.fillStyle = "white";
    if (this._fillColor){
        ctx.fillStyle = this.buildColor(ctx, this._fillColor, w, h, this._strokeWidth);
    }
    var lineCap = ['butt','round','square'];
    ctx.lineCap = lineCap[1];
    var lineJoin = ['round','bevel','miter'];
    ctx.lineJoin = lineJoin[0];


    //commenting this out for now because of Chrome bug where coincident endpoints of bezier curve cause the curve to not be rendered
    /*
    ctx.beginPath();
    var prevAnchor = this.getAnchor(0);
    ctx.moveTo(prevAnchor.getPosX(),prevAnchor.getPosY());
    for (var i = 1; i < numAnchors; i++) {
        var currAnchor = this.getAnchor(i);
        ctx.bezierCurveTo(prevAnchor.getNextX(),prevAnchor.getNextY(), currAnchor.getPrevX(), currAnchor.getPrevY(), currAnchor.getPosX(), currAnchor.getPosY());
        prevAnchor = currAnchor;
    }
    if (this._isClosed === true) {
        var currAnchor = this.getAnchor(0);
        ctx.bezierCurveTo(prevAnchor.getNextX(),prevAnchor.getNextY(), currAnchor.getPrevX(), currAnchor.getPrevY(), currAnchor.getPosX(), currAnchor.getPosY());
        prevAnchor = currAnchor;
    }
    ctx.fill();
    ctx.stroke();
    */


    ctx.beginPath();
    ctx.moveTo(this._Samples[0][0],this._Samples[0][1]);
    for (var i=0;i<numPoints;i++){
        ctx.lineTo(this._Samples[i][0],this._Samples[i][1]);
    }
    if (this._isClosed === true) {
        ctx.lineTo(this._Samples[0][0],this._Samples[0][1]);
    }
    ctx.fill();
    ctx.stroke();

    ctx.restore();
}; //render()

/////////////////////////////////////////////////////////
// Property Accessors/Setters
/////////////////////////////////////////////////////////


GLSubpath.prototype.geomType = function () {
    return this.GEOM_TYPE_CUBIC_BEZIER;
};

GLSubpath.prototype.setWidth = function (newW) {
    var strokeWidth = this._strokeWidth;
    var halfStrokeWidth = strokeWidth*0.5;
    var minWidth = 1+strokeWidth;
    if (newW<minWidth) {
        newW=minWidth;
    }

    //scale the contents of this subpath to lie within this width
    //determine the scale factor by comparing with the old width
    var oldCanvasWidth = this._BBoxMax[0]-this._BBoxMin[0];
    if (oldCanvasWidth<minWidth) {
        oldCanvasWidth=minWidth;
    }

    var scaleX = (newW-strokeWidth)/(oldCanvasWidth-strokeWidth);
    if (scaleX===1) {
        return; //no need to do anything
    }

    //scale the anchor point positions such that the width of the bbox is the newW
    var origX = halfStrokeWidth;//this is the left edge    //this._BBoxMin[0]; //this should always be zero since we only deal with local coordinates
    var numAnchors = this._Anchors.length;
    for (var i=0;i<numAnchors;i++){
        //compute the distance from the bboxMin
        var oldW = this._Anchors[i].getPosX() - origX;
        var prevW = this._Anchors[i].getPrevX() - origX;
        var nextW = this._Anchors[i].getNextX() - origX;

        this._Anchors[i].setPos(origX + oldW*scaleX,this._Anchors[i].getPosY(),this._Anchors[i].getPosZ());
        this._Anchors[i].setPrevPos(origX + prevW*scaleX,this._Anchors[i].getPrevY(),this._Anchors[i].getPrevZ());
        this._Anchors[i].setNextPos(origX + nextW*scaleX,this._Anchors[i].getNextY(),this._Anchors[i].getNextZ());
    }
    this.makeDirty();
    this.computeBoundingBox(true, false);
};

GLSubpath.prototype.setHeight = function (newH) {
    var strokeWidth = this._strokeWidth;
    var halfStrokeWidth = strokeWidth*0.5;
    var minHeight = 1+strokeWidth;

    if (newH<minHeight) {
        newH=minHeight; //clamp minimum width to 1
    }
    //scale the contents of this subpath to lie within this height
    //determine the scale factor by comparing with the old height
    var oldHeight = this._BBoxMax[1]-this._BBoxMin[1];
    if (oldHeight<minHeight){
        oldHeight=minHeight;
    }

    var scaleY = (newH-strokeWidth)/(oldHeight-strokeWidth);
    if (scaleY===1){
        return; //no need to do anything
    }

    //scale the anchor point positions such that the height of the bbox is the newH
    var origY = halfStrokeWidth;// this._BBoxMin[1];//this is the top edge
    var numAnchors = this._Anchors.length;
    for (var i=0;i<numAnchors;i++){
        //compute the distance from the bboxMin
        var oldW = this._Anchors[i].getPosY() - origY;
        var prevW = this._Anchors[i].getPrevY() - origY;
        var nextW = this._Anchors[i].getNextY() - origY;

        this._Anchors[i].setPos(this._Anchors[i].getPosX(), origY + oldW*scaleY,this._Anchors[i].getPosZ());
        this._Anchors[i].setPrevPos(this._Anchors[i].getPrevX(), origY + prevW*scaleY,this._Anchors[i].getPrevZ());
        this._Anchors[i].setNextPos(this._Anchors[i].getNextX(), origY + nextW*scaleY,this._Anchors[i].getNextZ());
    }
    this.makeDirty();
    this.computeBoundingBox(true, false);
};

GLSubpath.prototype.setWorld = function (world) {
    this._world = world;
};

GLSubpath.prototype.setCanvas = function (canvas){
    this._canvas = canvas;
};

GLSubpath.prototype.getWorld = function () {
    return this._world;
};

GLSubpath.prototype.getCanvas = function() {
    return this._canvas;
};
GLSubpath.prototype.makeDirty = function () {
    this._dirty = true;
};

GLSubpath.prototype.setDrawingTool = function (tool) {
    this._drawingTool = tool;
};

GLSubpath.prototype.getDrawingTool = function () {
    return this._drawingTool;
};


GLSubpath.prototype.getIsClosed = function () {
    return this._isClosed;
};

GLSubpath.prototype.setIsClosed = function (isClosed) {
    if (this._isClosed !== isClosed) {
        this._isClosed = isClosed;
        this.makeDirty();
    }
};

GLSubpath.prototype.setCanvasCenterLocalCoord = function(center){
    this._canvasCenterLocalCoord = center;
};

GLSubpath.prototype.getCanvasCenterLocalCoord = function(){
    return [this._canvasCenterLocalCoord[0],this._canvasCenterLocalCoord[1],this._canvasCenterLocalCoord[2]];
};

GLSubpath.prototype.getNumAnchors = function () {
    return this._Anchors.length;
};

GLSubpath.prototype.getAnchor = function (index) {
    return this._Anchors[index];
};

GLSubpath.prototype.addAnchor = function (anchorPt) {
    this._Anchors.push(anchorPt);
    this._selectedAnchorIndex = this._Anchors.length-1;
    this.makeDirty();
};

GLSubpath.prototype.insertAnchor = function(anchorPt, index){
    this._Anchors.splice(index, 0, anchorPt);
    this.makeDirty();
};

//remove and return anchor at specified index, return null on error
GLSubpath.prototype.removeAnchor = function (index) {
    var retAnchor = null;
    if (index < this._Anchors.length) {
        //if this is a closed path and we've removed either endpoint, we simply mark it as open
        if (this._isClosed && (index===this._Anchors.length-1 || index===0)){
            this.setIsClosed(false);
        } else {
            retAnchor = this._Anchors.splice(index, 1);
        }
        this.makeDirty();
        
    }
    //deselect any selected anchor point
    this.deselectAnchorPoint();
    return retAnchor;
};

GLSubpath.prototype.deselectAnchorPoint = function(){
    this._selectedAnchorIndex = -1;
};

GLSubpath.prototype.reversePath = function() {
    var revAnchors = [];
    var numAnchors = this._Anchors.length;
    var lastIndex = numAnchors-1;
    if (lastIndex<0){
        return; //cannot reverse empty path
    }
    for (var i=lastIndex;i>=0;i--) {
        var newAnchor = new AnchorPoint();
        var oldAnchor = this._Anchors[i];
        newAnchor.setPos(oldAnchor.getPosX(),oldAnchor.getPosY(),oldAnchor.getPosZ());
        newAnchor.setPrevPos(oldAnchor.getNextX(),oldAnchor.getNextY(),oldAnchor.getNextZ());
        newAnchor.setNextPos(oldAnchor.getPrevX(),oldAnchor.getPrevY(),oldAnchor.getPrevZ());
        revAnchors.push(newAnchor);
    }
    if (this._selectedAnchorIndex >= 0){
        this._selectedAnchorIndex = (numAnchors-1) - this._selectedAnchorIndex;
    }
    this._Anchors = revAnchors;
    this.makeDirty();
};

//remove all the anchor points
GLSubpath.prototype.clearAllAnchors = function () {
    this._Anchors = [];
    this.deselectAnchorPoint();
    this.setIsClosed(false);
    this.makeDirty();
};

GLSubpath.prototype.insertAnchorAtParameter = function(index, param) {
    if (index+1 >= this._Anchors.length && !this._isClosed) {
        return;
    }
    //insert an anchor after the specified index using the parameter, using De Casteljau subdivision
    var nextIndex = (index+1)%this._Anchors.length;

    //build the De Casteljau points
    var P0P1 = VecUtils.vecInterpolate(3, this._Anchors[index].getPos(), this._Anchors[index].getNext(), param);
    var P1P2 = VecUtils.vecInterpolate(3, this._Anchors[index].getNext(), this._Anchors[nextIndex].getPrev(), param);
    var P2P3 = VecUtils.vecInterpolate(3, this._Anchors[nextIndex].getPrev(), this._Anchors[nextIndex].getPos(), param);

    var P0P1P2 = VecUtils.vecInterpolate(3, P0P1, P1P2, param);
    var P1P2P3 = VecUtils.vecInterpolate(3, P1P2, P2P3, param);
    var anchorPos = VecUtils.vecInterpolate(3, P0P1P2, P1P2P3, param);


    //update the next of the anchor at index and prev of anchor at nextIndex
    var isPrevCoincident = false;
    var isNextCoincident = false;
    if (VecUtils.vecDist( 3, P0P1, this._Anchors[index].getNext()) < this._SAMPLING_EPSILON) {
        //no change to the next point
        isPrevCoincident = true;
    } else {
        this._Anchors[index].setNextPos(P0P1[0], P0P1[1], P0P1[2]);
    }

    if (VecUtils.vecDist( 3, P2P3, this._Anchors[nextIndex].getPrev()) < this._SAMPLING_EPSILON) {
        //no change to the prev point
        isNextCoincident = true;
    } else {
        this._Anchors[nextIndex].setPrevPos(P2P3[0], P2P3[1], P2P3[2]);
    }

    //create a new anchor point
    var newAnchor = new AnchorPoint();

    if (isPrevCoincident && isNextCoincident){
        anchorPos[0]=P1P2[0];anchorPos[1]=P1P2[1];anchorPos[2]=P1P2[2];
        newAnchor.setPos(anchorPos[0],anchorPos[1],anchorPos[2]);
        newAnchor.setPrevPos(anchorPos[0],anchorPos[1],anchorPos[2]);
        newAnchor.setNextPos(anchorPos[0],anchorPos[1],anchorPos[2]);
    } else {
        newAnchor.setPrevPos(P0P1P2[0], P0P1P2[1], P0P1P2[2]);
        newAnchor.setNextPos(P1P2P3[0], P1P2P3[1], P1P2P3[2]);
        newAnchor.setPos(anchorPos[0], anchorPos[1], anchorPos[2]);
    }

    //insert the new anchor point at the correct index and set it as the selected anchor
    this._Anchors.splice(nextIndex, 0, newAnchor);
    this._selectedAnchorIndex = nextIndex;
    this.makeDirty();
};


GLSubpath.prototype.isWithinPathBBox = function(x,y,z) {
    if (this._BBoxMin[0]>x || this._BBoxMin[1]>y || this._BBoxMin[2]>z){
        return false;
    }
    if (this._BBoxMax[0]<x || this._BBoxMax[1]<y || this._BBoxMax[2]<z){
        return false;
    }
    return true;
}


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
    //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._Samples.length-1;
    }
    var retParam = null;
    for (var i=startIndex; i<endIndex; i++){
        var seg0 = this._Samples[i].slice(0);
        var j=i+1;
        var seg1 = this._Samples[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
            retParam = this._sampleParam[i] + (this._sampleParam[j] - this._sampleParam[i])*paramDistance;
            break;
        }
    }
    return retParam;
};

GLSubpath.prototype._checkIntersection = function(controlPts, beginParam, endParam, point, radius) {
    //check whether the point is within radius distance from the curve
    // if there is an intersection, return the parameter value (between beginParam and endParam) of the intersection point, else return null
    var bboxMin = [Infinity, Infinity, Infinity];
    var bboxMax = [-Infinity,-Infinity,-Infinity];
    for (var i=0;i<controlPts.length;i++) {
        for (var d=0;d<3;d++){
            if (controlPts[i][d] < bboxMin[d]){
                bboxMin[d] = controlPts[i][d];
            }
            if (controlPts[i][d] > bboxMax[d]){
                bboxMax[d] = controlPts[i][d];
            }
        }
    }
    //check whether the bbox of the control points contains the point within the specified radius
    for (var d=0;d<3;d++){
        if (point[d] < (bboxMin[d]-radius)){
            return null;
        }
        if (point[d] > (bboxMax[d]+radius)){
            return null;
        }
    }

    //check if the curve is already flat, and if so, check the distance from the segment C0C3 to the point
    //measure distance of C1 and C2 to segment C0-C3
    var distC1 = MathUtils.distPointToSegment(controlPts[1], controlPts[0], controlPts[3]);
    var distC2 = MathUtils.distPointToSegment(controlPts[2], controlPts[0], controlPts[3]);
    var maxDist = Math.max(distC1, distC2);
    var threshold = this._SAMPLING_EPSILON; //this should be set outside this function //TODO
    if (maxDist < threshold) { //if the curve is flat
        var distP = MathUtils.distPointToSegment(point, controlPts[0], controlPts[3]); //TODO we may need to neglect cases where the non-perpendicular distance is used...
        if (distP>radius) {
            return null;
        } else {
            var param = MathUtils.paramPointProjectionOnSegment(point, controlPts[0], controlPts[3]); //TODO this function is already called in distPointToSegment...optimize by removing redundant call
            //var param = VecUtils.vecDist(3, point, controlPts[0])/VecUtils.vecDist(3, controlPts[3], controlPts[0]);
            if (param<0)
                param=0;
            if (param>1)
                param=1;

            return beginParam + (endParam-beginParam)*param;
        }
    }

    //subdivide this curve using De Casteljau interpolation
    var C0_ = VecUtils.vecInterpolate(3, controlPts[0], controlPts[1], 0.5);
    var C1_ = VecUtils.vecInterpolate(3, controlPts[1], controlPts[2], 0.5);
    var C2_ = VecUtils.vecInterpolate(3, controlPts[2], controlPts[3], 0.5);

    var C0__ = VecUtils.vecInterpolate(3, C0_, C1_, 0.5);
    var C1__ = VecUtils.vecInterpolate(3, C1_, C2_, 0.5);

    var C0___ = VecUtils.vecInterpolate(3, C0__, C1__, 0.5);

    //recursively sample the first half of the curve
    var midParam = (endParam+beginParam)*0.5;