From 40f3fc5feae866c99af818a886e8bf9d8cf2b8dd Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 6 Mar 2012 17:23:58 -0800
Subject: merge Valerio's architecture changes into pen tool

---
 js/lib/geom/sub-path.js | 84 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index ab54d1e9..0a65511b 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -584,6 +584,90 @@ GLSubpath.prototype.pickAnchor = function (pickX, pickY, pickZ, radius) {
     return selAnchorIndex;
 };
 
+GLSubpath.prototype.isWithinBBox =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;
+}
+
+//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;
+    var selAnchorIndex = -1;
+    var retParam = null;
+    var radSq = radius * radius;
+    var minDistance = Infinity;
+
+    //check if the location is close to the currently selected anchor position
+    if (this._selectedAnchorIndex>=0 && this._selectedAnchorIndex<this._Anchors.length){
+        var distSq = this._Anchors[this._selectedAnchorIndex].getDistanceSq(pickX, pickY, pickZ);
+        //check the anchor point
+        if (distSq < minDistance && distSq < radSq) {
+            selAnchorIndex = this._selectedAnchorIndex;
+            minDistance = distSq;
+        }
+    }
+    //check the prev and next of the selected anchor if the above did not register a hit
+    if (this._selectedAnchorIndex>=0 && selAnchorIndex === -1) {
+        var distSq = this._Anchors[this._selectedAnchorIndex].getPrevDistanceSq(pickX, pickY, pickZ);
+        if (distSq < minDistance && distSq < radSq){
+            selAnchorIndex = this._selectedAnchorIndex;
+            minDistance = distSq;
+        } else {
+            //check the next for this anchor point
+            distSq = this._Anchors[this._selectedAnchorIndex].getNextDistanceSq(pickX, pickY, pickZ);
+            if (distSq<minDistance && distSq<radSq){
+                selAnchorIndex = this._selectedAnchorIndex;
+                minDistance = distSq;
+            }
+        }
+    }
+
+    //now check if the location is close to any anchor position
+    if (selAnchorIndex===-1) {
+        for (var i = 0; i < numAnchors; i++) {
+            var distSq = this._Anchors[i].getDistanceSq(pickX, pickY, pickZ);
+            //check the anchor point
+            if (distSq < minDistance && distSq < radSq) {
+                selAnchorIndex = i;
+                minDistance = distSq;
+            }
+        }//for every anchor i
+    }
+
+    //finally check if the location is close to the curve itself
+    if (selAnchorIndex===-1) {
+        //first check if the input location is within the bounding box
+        if (this.isWithinBBox(pickX,pickY,pickZ)){
+            var numSegments = this._isClosed ? numAnchors : numAnchors-1;
+            for (var i = 0; i < numSegments; i++) {
+                var nextIndex = (i+1)%numAnchors;
+                //check if the point is close to the bezier segment between anchor i and anchor nextIndex
+                var controlPoints = [[this._Anchors[i].getPosX(),this._Anchors[i].getPosY(),this._Anchors[i].getPosZ()],
+                    [this._Anchors[i].getNextX(),this._Anchors[i].getNextY(),this._Anchors[i].getNextZ()],
+                    [this._Anchors[nextIndex].getPrevX(),this._Anchors[nextIndex].getPrevY(),this._Anchors[nextIndex].getPrevZ()],
+                    [this._Anchors[nextIndex].getPosX(),this._Anchors[nextIndex].getPosY(),this._Anchors[nextIndex].getPosZ()]];
+                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._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
+                        break;
+                    }
+                }
+            }//for every anchor i
+        }//if is within bbox
+    }
+    return [selAnchorIndex,retParam];
+}     //GLSubpath.pathHitTest function
+
 //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.pickPath = function (pickX, pickY, pickZ, radius) {
     var numAnchors = this._Anchors.length;
-- 
cgit v1.2.3


From 353bfa04a6153b0146a0c73b6e6bb0e5f4b23194 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 6 Mar 2012 17:40:22 -0800
Subject: merge Valerio's architecture changes

---
 js/lib/geom/brush-stroke.js | 177 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 172 insertions(+), 5 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 9a934928..39af5c5c 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -32,6 +32,8 @@ var BrushStroke = function GLBrushStroke() {
     //stroke information
     this._strokeWidth = 0.0;
     this._strokeColor = [0.4, 0.4, 0.4, 1.0];
+    this._secondStrokeColor = this._strokeColor;
+    this._strokeHardness = 100;
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
 
@@ -114,7 +116,7 @@ var BrushStroke = function GLBrushStroke() {
         //add the point only if it is some epsilon away from the previous point
         var numPoints = this._Points.length;
         if (numPoints>0) {
-            var threshold = this._WETNESS_FACTOR*this._strokeWidth;
+            var threshold = 1;//this._WETNESS_FACTOR*this._strokeWidth;
             var prevPt = this._Points[numPoints-1];
             var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
             var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
@@ -173,6 +175,14 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeColor = c;
     };
 
+    this.setSecondStrokeColor = function(c){
+        this._secondStrokeColor=c;
+    }
+
+    this.setStrokeHardness = function(h){
+        this._strokeHardness=h;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -219,7 +229,8 @@ var BrushStroke = function GLBrushStroke() {
             var numPoints = this._Points.length;
 
             //**** add samples to the path if needed...linear interpolation for now
-            if (numPoints>1) {
+            //if (numPoints>1) {
+            if (0){
                 var threshold = this._WETNESS_FACTOR*this._strokeWidth;
                 var prevPt = this._Points[0];
                 var prevIndex = 0;
@@ -250,6 +261,44 @@ var BrushStroke = function GLBrushStroke() {
                     }
                 }
             }
+            //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
+            if (numPoints>1) {
+                var numInsertedPoints = 0;
+                var threshold = 5;//0.25*this._strokeWidth; //this determines whether a segment between two sample is too long
+                var prevPt = this._Points[0];
+                for (var i=1;i<numPoints;i++){
+                    var pt = this._Points[i];
+                    var diff = [pt[0]-prevPt[0], pt[1]-prevPt[1]];
+                    var distance = Math.sqrt(diff[0]*diff[0]+diff[1]*diff[1]);
+                    if (distance>threshold){
+                        //build the control polygon for the Catmull-Rom spline (prev. 2 points and next 2 points)
+                        var prev = (i===1) ? i-1 : i-2;
+                        var next = (i===numPoints-1) ? i : i+1;
+                        var ctrlPts = [this._Points[prev], this._Points[i-1], this._Points[i], this._Points[next]];
+                        //insert points along the prev. to current point
+                        var numNewPoints = Math.floor(distance/threshold);
+                        for (var j=0;j<numNewPoints;j++){
+                            var param = (j+1)/(numNewPoints+1);
+                            var newpt = this._CatmullRomSplineInterpolate(ctrlPts, param);
+                            //insert new point before point i
+                            this._Points.splice(i, 0, newpt);
+                            i++;
+                            numInsertedPoints++;
+                        }
+                        this._dirty=true;
+                    }
+                    prevPt=pt;
+                    //update numPoints to match the new length
+                    numPoints = this._Points.length;
+
+                    //end this function if the numPoints has gone above the max. size specified
+                    if (numPoints> this._MAX_ALLOWED_SAMPLES){
+                        console.log("leaving the resampling because numPoints is greater than limit:"+this._MAX_ALLOWED_SAMPLES);
+                        break;
+                    }
+                }
+                console.log("Inserted "+numInsertedPoints+" additional CatmullRom points");
+            }
 
             // *** compute the bounding box *********
             this._BBoxMin = [Infinity, Infinity, Infinity];
@@ -412,7 +461,7 @@ var BrushStroke = function GLBrushStroke() {
         }
         */
 
-
+        /*
         var R2 = this._strokeWidth;
         var R = R2*0.5;
         var hardness = 0; //for a pencil, this is always 1 //TODO get hardness parameter from user interface
@@ -440,6 +489,109 @@ var BrushStroke = function GLBrushStroke() {
             //ctx.globalCompositeOperation = 'source-in';
             //ctx.rect(x-R, y-R, R2, R2);
         }
+        */
+
+        /*
+        //build the stamp for the brush stroke
+        //todo get this directly from the UI
+        var t=0;
+        var numTraces = this._strokeWidth;
+        var halfNumTraces = numTraces/2;
+        var startPos = [-this._strokeWidth/2,0];
+        var brushStamp = [];
+
+        //build an angled (calligraphic) brush stamp
+        var deltaDisplacement = [1,1];//[this._strokeWidth/numTraces, 0]; //a horizontal line brush
+        for (t=0;t<numTraces;t++){
+            var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
+            brushStamp.push(brushPt);
+        }
+
+
+        //make a circular brush stamp
+        brushStamp=[];
+        numTraces = this._strokeWidth*Math.PI; //figure out how to
+        var radius = this._strokeWidth/2;
+        for (t=0;t<numTraces;t++)
+        {
+            var angle = Math.PI*(360*t/numTraces)/180;
+            var brushPt = [radius*Math.cos(angle), radius*Math.sin(angle)];
+            brushStamp.push(brushPt);
+        }
+
+//        //make a square brush stamp
+//        STOPPED HERE
+//        brushStamp = [];
+//        numTraces = 4*strokeWidth;
+//        for (t=0;t<numTraces;t++){
+//            if (t<numTraces*0.25){
+//                var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
+//            } else if (t<numTraces*0.5){
+//
+//            } else if (t<numTraces*0.75){
+//
+//            } else {
+//
+//            }
+//            brushStamp.push(brushPt);
+//        }
+
+        for (t=0;t<numTraces;t++){
+            var disp = [brushStamp[t][0], brushStamp[t][1]];
+            //ctx.globalCompositeOperation = 'source-over';
+            var distFromMiddle = Math.abs(halfNumTraces-t);
+            var alphaVal = 1.0 - (100-this._strokeHardness)*(distFromMiddle/halfNumTraces)/100;
+            alphaVal = 0.2;
+            ctx.save();
+            ctx.lineWidth=this._strokeWidth/10;//todo figure out the correct formula for the line width
+            if (ctx.lineWidth<2)
+                ctx.lineWidth=2;
+            if (t===numTraces-1){
+                ctx.lineWidth = 1;
+            }
+            ctx.lineJoin="bevel";
+            ctx.lineCap="butt";
+            //if (t<numTraces/2)
+                ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+            //else
+            //    ctx.strokeStyle="rgba("+parseInt(255*this._secondStrokeColor[0])+","+parseInt(255*this._secondStrokeColor[1])+","+parseInt(255*this._secondStrokeColor[2])+","+alphaVal+")";
+            ctx.translate(disp[0],disp[1]);
+            ctx.beginPath();
+            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            for (var i=0;i<numPoints;i++){
+                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+            }
+            ctx.stroke();
+            ctx.restore();
+        }
+        */
+
+        /*
+        //debugging path
+        ctx.beginPath();
+        ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+        for (var i=1;i<numPoints;i++){
+            ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+        }
+        ctx.lineWidth=1.0;
+        ctx.strokeStyle = "black";
+        ctx.stroke();
+        */
+
+        var numlayers = this._strokeWidth/2;
+        var alphaVal = 1.0/(numlayers-1);
+        for (var l=0;l<numlayers;l++){
+            ctx.beginPath();
+            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            for (var i=1;i<numPoints;i++){
+                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+            }
+            ctx.lineCap = "round";
+            ctx.lineJoin="round";
+            ctx.lineWidth=l+1;
+            ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+            ctx.stroke();
+        }
 
         ctx.restore();
     }; //render()
@@ -473,10 +625,25 @@ var BrushStroke = function GLBrushStroke() {
         return true;
     };
 
-}; //function GLSubpath ...class definition
+}; //function BrushStroke ...class definition
 
 BrushStroke.prototype = new GeomObj();
 
+BrushStroke.prototype._CatmullRomSplineInterpolate = function(ctrlPts, t)
+{
+    //perform CatmullRom interpolation on the spline...assume t is in [0,1]
+    var t2 = t*t;
+    var t3 = t2*t;
+    var retPoint = [0,0,0];
+    for (var i=0;i<3;i++){
+        retPoint[i] = 0.5 *(
+            (2*ctrlPts[1][i]) +
+            (-ctrlPts[0][i] + ctrlPts[2][i]) * t +
+            (2*ctrlPts[0][i] - 5*ctrlPts[1][i] + 4*ctrlPts[2][i] - ctrlPts[3][i]) * t2 +
+            (-ctrlPts[0][i] + 3*ctrlPts[1][i]- 3*ctrlPts[2][i] + ctrlPts[3][i]) * t3);
+    }
+    return retPoint;
+}
 if (typeof exports === "object") {
     exports.BrushStroke = BrushStroke;
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3


From 2a8a41711052bb557271c27f82faba8dd13fd880 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Wed, 7 Mar 2012 06:12:34 -0800
Subject: preliminary support for setting gradients on webgl shapes.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/geom-obj.js | 65 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 52 insertions(+), 13 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/geom-obj.js b/js/lib/geom/geom-obj.js
index c5880843..726c3595 100755
--- a/js/lib/geom/geom-obj.js
+++ b/js/lib/geom/geom-obj.js
@@ -138,22 +138,61 @@ var GeomObj = function GLGeomObj() {
     // Methods
     ///////////////////////////////////////////////////////////////////////
 	this.setMaterialColor = function(c, type) {
-		if (type == "fill") {
-			this._fillColor = c.slice(0);
+        if(c.gradientMode) {
+            var nMats = 0;
+            if (this._materialArray && this._materialTypeArray) {
+                nMats = this._materialArray.length;
+            }
+
+            var stops = [],
+                colors = c.color;
+
+            var len = colors.length;
+            // TODO - Current shaders only support 4 color stops
+            if(len > 4) {
+                len = 4;
+            }
+
+            for(var n=0; n<len; n++) {
+                var position = colors[n].position/100;
+                var cs = colors[n].value;
+                var stop = [cs.r/255, cs.g/255, cs.b/255, cs.a];
+                stops.push(stop);
+
+                if (nMats === this._materialTypeArray.length) {
+                    for (var i=0;  i<nMats;  i++) {
+                        if (this._materialTypeArray[i] == type) {
+                            this._materialArray[i].setProperty( "color"+(n+1), stop.slice(0) );
+                            this._materialArray[i].setProperty( "colorStop"+(n+1), position );
+                        }
+                    }
+                }
+            }
+//            if (type == "fill") {
+//                this._fillColor = c.slice(0);
+//            } else {
+//                this._strokeColor = c.slice(0);
+//            }
         } else {
-			this._strokeColor = c.slice(0);
-        }
+            if (type == "fill") {
+                this._fillColor = c.slice(0);
+            } else {
+                this._strokeColor = c.slice(0);
+            }
 
-		if (this._materialArray && this._materialTypeArray) {
-			var nMats = this._materialArray.length;
-			if (nMats === this._materialTypeArray.length) {
-				for (var i=0;  i<nMats;  i++) {
-					if (this._materialTypeArray[i] == type) {
-						this._materialArray[i].setProperty( "color", c.slice(0) );
+            if (this._materialArray && this._materialTypeArray) {
+                var nMats = this._materialArray.length;
+                if (nMats === this._materialTypeArray.length) {
+                    for (var i=0;  i<nMats;  i++) {
+                        if (this._materialTypeArray[i] == type) {
+                            this._materialArray[i].setProperty( "color", c.slice(0) );
+                        }
                     }
-				}
-			}
-		}
+                }
+            }
+        }
+
+
 
 		var world = this.getWorld();
 		if (world)  {
-- 
cgit v1.2.3


From 443a23289171bb72324e740d8eaa041968a1de99 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Wed, 7 Mar 2012 10:30:15 -0800
Subject: Fix for stroke and fill gradients not being retained when drawing
 multiple shapes and switching between them.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/geom-obj.js | 39 ++++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/geom-obj.js b/js/lib/geom/geom-obj.js
index 726c3595..1ea74475 100755
--- a/js/lib/geom/geom-obj.js
+++ b/js/lib/geom/geom-obj.js
@@ -138,8 +138,10 @@ var GeomObj = function GLGeomObj() {
     // Methods
     ///////////////////////////////////////////////////////////////////////
 	this.setMaterialColor = function(c, type) {
+        var i = 0,
+            nMats = 0;
         if(c.gradientMode) {
-            var nMats = 0;
+            // Gradient support
             if (this._materialArray && this._materialTypeArray) {
                 nMats = this._materialArray.length;
             }
@@ -160,7 +162,7 @@ var GeomObj = function GLGeomObj() {
                 stops.push(stop);
 
                 if (nMats === this._materialTypeArray.length) {
-                    for (var i=0;  i<nMats;  i++) {
+                    for (i=0;  i<nMats;  i++) {
                         if (this._materialTypeArray[i] == type) {
                             this._materialArray[i].setProperty( "color"+(n+1), stop.slice(0) );
                             this._materialArray[i].setProperty( "colorStop"+(n+1), position );
@@ -168,22 +170,22 @@ var GeomObj = function GLGeomObj() {
                     }
                 }
             }
-//            if (type == "fill") {
-//                this._fillColor = c.slice(0);
-//            } else {
-//                this._strokeColor = c.slice(0);
-//            }
+            if (type === "fill") {
+                this._fillColor = c;
+            } else {
+                this._strokeColor = c;
+            }
         } else {
-            if (type == "fill") {
+            if (type === "fill") {
                 this._fillColor = c.slice(0);
             } else {
                 this._strokeColor = c.slice(0);
             }
 
             if (this._materialArray && this._materialTypeArray) {
-                var nMats = this._materialArray.length;
+                nMats = this._materialArray.length;
                 if (nMats === this._materialTypeArray.length) {
-                    for (var i=0;  i<nMats;  i++) {
+                    for (i=0;  i<nMats;  i++) {
                         if (this._materialTypeArray[i] == type) {
                             this._materialArray[i].setProperty( "color", c.slice(0) );
                         }
@@ -192,8 +194,6 @@ var GeomObj = function GLGeomObj() {
             }
         }
 
-
-
 		var world = this.getWorld();
 		if (world)  {
             world.restartRenderLoop();
@@ -210,14 +210,15 @@ var GeomObj = function GLGeomObj() {
 
         if (strokeMaterial) {
             strokeMaterial.init( this.getWorld() );
-            if(this._strokeColor) {
-                strokeMaterial.setProperty("color", this._strokeColor);
-            }
         }
 
         this._materialArray.push( strokeMaterial );
         this._materialTypeArray.push( "stroke" );
 
+        if(this._strokeColor) {
+            this.setStrokeColor(this._strokeColor);
+        }
+
         return strokeMaterial;
     };
 
@@ -231,15 +232,15 @@ var GeomObj = function GLGeomObj() {
 
         if (fillMaterial) {
             fillMaterial.init( this.getWorld() );
-            //if(!this.getFillMaterial() && this._fillColor)
-            if (this._fillColor) {
-                fillMaterial.setProperty("color", this._fillColor);
-            }
         }
 
         this._materialArray.push( fillMaterial );
         this._materialTypeArray.push( "fill" );
 
+        if (this._fillColor) {
+            this.setFillColor(this._fillColor);
+        }
+
         return fillMaterial;
     };
 
-- 
cgit v1.2.3


From fc567223aded95c35982b1d1239f6d28a957a199 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Wed, 7 Mar 2012 11:42:46 -0800
Subject: Gradient support for canvas-2d rectangle.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/rectangle.js | 64 ++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 57 insertions(+), 7 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index 81b385b3..50271a13 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -459,15 +459,44 @@ var Rectangle = function GLRectangle() {
 		var lw = this._strokeWidth;
 		var	w = world.getViewportWidth(),
 			h = world.getViewportHeight();
-		
+
+        var c,
+            inset,
+            gradient,
+            colors,
+            len,
+            n,
+            position,
+            cs;
 		// render the fill
 		ctx.beginPath();
 		if (this._fillColor) {
-			var c = "rgba(" + 255*this._fillColor[0] + "," + 255*this._fillColor[1] + "," + 255*this._fillColor[2] + "," + this._fillColor[3] + ")";  
-			ctx.fillStyle = c;
+            inset = Math.ceil( lw ) + 0.5;
+
+            if(this._fillColor.gradientMode) {
+                if(this._fillColor.gradientMode === "radial") {
+                    gradient = ctx.createRadialGradient(w/2, h/2, h/2-inset, w/2, h/2, h-2*inset);
+                } else {
+                    gradient = ctx.createLinearGradient(inset, inset, w-inset, h-inset);
+                }
+                colors = this._fillColor.color;
+
+                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 + ")");
+                }
+
+                ctx.fillStyle = gradient;
+
+            } else {
+                c = "rgba(" + 255*this._fillColor[0] + "," + 255*this._fillColor[1] + "," + 255*this._fillColor[2] + "," + this._fillColor[3] + ")";
+                ctx.fillStyle = c;
+            }
 
 			ctx.lineWidth	= lw;
-			var inset = Math.ceil( lw ) + 0.5;
 			this.renderPath( inset, ctx );
 			ctx.fill();
 			ctx.closePath();
@@ -476,11 +505,32 @@ var Rectangle = function GLRectangle() {
 		// render the stroke
 		ctx.beginPath();
 		if (this._strokeColor) {
-			var c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";  
-			ctx.strokeStyle = c;
+            inset = Math.ceil( 0.5*lw ) + 0.5;
+
+            if(this._strokeColor.gradientMode) {
+                if(this._strokeColor.gradientMode === "radial") {
+                    gradient = ctx.createRadialGradient(w/2, h/2, h/2, w/2, h/2, h);
+                } else {
+                    gradient = ctx.createLinearGradient(0, 0, w, h);
+                }
+                colors = this._strokeColor.color;
+
+                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 + ")");
+                }
+
+                ctx.strokeStyle = gradient;
+
+            } else {
+                c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";
+                ctx.strokeStyle = c;
+            }
 
 			ctx.lineWidth	= lw;
-			var inset = Math.ceil( 0.5*lw ) + 0.5;
 			this.renderPath( inset, ctx );
 			ctx.stroke();
 			ctx.closePath();
-- 
cgit v1.2.3


From 5bef5c5f2f7ee45d4c619c65ab8e9307c30420b5 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Wed, 7 Mar 2012 11:52:41 -0800
Subject: Change linear gradient to go from left to right instead of top-left
 to bottom-right.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/rectangle.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index 50271a13..d01d5b28 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -477,7 +477,7 @@ var Rectangle = function GLRectangle() {
                 if(this._fillColor.gradientMode === "radial") {
                     gradient = ctx.createRadialGradient(w/2, h/2, h/2-inset, w/2, h/2, h-2*inset);
                 } else {
-                    gradient = ctx.createLinearGradient(inset, inset, w-inset, h-inset);
+                    gradient = ctx.createLinearGradient(inset, h/2, w-2*inset, h/2);
                 }
                 colors = this._fillColor.color;
 
@@ -511,7 +511,7 @@ var Rectangle = function GLRectangle() {
                 if(this._strokeColor.gradientMode === "radial") {
                     gradient = ctx.createRadialGradient(w/2, h/2, h/2, w/2, h/2, h);
                 } else {
-                    gradient = ctx.createLinearGradient(0, 0, w, h);
+                    gradient = ctx.createLinearGradient(0, h/2, w, h/2);
                 }
                 colors = this._strokeColor.color;
 
-- 
cgit v1.2.3


From 703fb3d06e88257ac73c1d1a0ec6ca33a64f4371 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Wed, 7 Mar 2012 14:33:21 -0800
Subject: implement stroke hardness such that it is percentage of the stroke
 width that's fully the color of the brush

AND
add a smoothing flag for the brush options
---
 js/lib/geom/brush-stroke.js | 66 +++++++++++++--------------------------------
 1 file changed, 19 insertions(+), 47 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 39af5c5c..3e64e730 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -36,6 +36,7 @@ var BrushStroke = function GLBrushStroke() {
     this._strokeHardness = 100;
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
+    this._strokeDoSmoothing = false;
 
     //the wetness of the brush (currently this is multiplied to the square of the stroke width, but todo should be changed to not depend on stroke width entirely
     //smaller value means more samples for the path
@@ -183,6 +184,10 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeHardness=h;
     }
 
+    this.setDoSmoothing = function(s){
+        this._strokeDoSmoothing = s;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -262,7 +267,7 @@ var BrushStroke = function GLBrushStroke() {
                 }
             }
             //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
-            if (numPoints>1) {
+            if (this._strokeDoSmoothing && numPoints>1) {
                 var numInsertedPoints = 0;
                 var threshold = 5;//0.25*this._strokeWidth; //this determines whether a segment between two sample is too long
                 var prevPt = this._Points[0];
@@ -507,35 +512,6 @@ var BrushStroke = function GLBrushStroke() {
             brushStamp.push(brushPt);
         }
 
-
-        //make a circular brush stamp
-        brushStamp=[];
-        numTraces = this._strokeWidth*Math.PI; //figure out how to
-        var radius = this._strokeWidth/2;
-        for (t=0;t<numTraces;t++)
-        {
-            var angle = Math.PI*(360*t/numTraces)/180;
-            var brushPt = [radius*Math.cos(angle), radius*Math.sin(angle)];
-            brushStamp.push(brushPt);
-        }
-
-//        //make a square brush stamp
-//        STOPPED HERE
-//        brushStamp = [];
-//        numTraces = 4*strokeWidth;
-//        for (t=0;t<numTraces;t++){
-//            if (t<numTraces*0.25){
-//                var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
-//            } else if (t<numTraces*0.5){
-//
-//            } else if (t<numTraces*0.75){
-//
-//            } else {
-//
-//            }
-//            brushStamp.push(brushPt);
-//        }
-
         for (t=0;t<numTraces;t++){
             var disp = [brushStamp[t][0], brushStamp[t][1]];
             //ctx.globalCompositeOperation = 'source-over';
@@ -566,30 +542,26 @@ var BrushStroke = function GLBrushStroke() {
         }
         */
 
-        /*
-        //debugging path
-        ctx.beginPath();
-        ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
-        for (var i=1;i<numPoints;i++){
-            ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
-        }
-        ctx.lineWidth=1.0;
-        ctx.strokeStyle = "black";
-        ctx.stroke();
-        */
 
-        var numlayers = this._strokeWidth/2;
-        var alphaVal = 1.0/(numlayers-1);
+        var minStrokeWidth = (this._strokeHardness*this._strokeWidth)/100; //the hardness is the percentage of the stroke width that's fully opaque
+        var numlayers = 1 + (this._strokeWidth-minStrokeWidth)/2;
+        var alphaVal = 1.0/(numlayers);
+        ctx.lineCap = "round";
+        ctx.lineJoin="round";
+        ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+        ctx.globalCompositeOperation = 'lighter'; //we wish to add up the colors
+        ctx.globalAlpha = this._strokeColor[3];
         for (var l=0;l<numlayers;l++){
             ctx.beginPath();
             ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            if (numPoints===1){
+               ctx.lineTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]+0.01);
+            }
             for (var i=1;i<numPoints;i++){
                 ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
             }
-            ctx.lineCap = "round";
-            ctx.lineJoin="round";
-            ctx.lineWidth=l+1;
-            ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+
+            ctx.lineWidth=2*l+minStrokeWidth;
             ctx.stroke();
         }
 
-- 
cgit v1.2.3


From b6288e1ffe4ffe29a595bb1e146feb388503e2c4 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Wed, 7 Mar 2012 15:31:20 -0800
Subject: gradient support for canvas-2d shapes.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/circle.js    | 61 ++++++++++++++++++++++++++++++++++++++++++------
 js/lib/geom/line.js      | 38 ++++++++++++++++++++++++++----
 js/lib/geom/rectangle.js |  4 ++--
 3 files changed, 90 insertions(+), 13 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index dd82a4cc..70f608be 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -442,16 +442,43 @@ var Circle = function GLCircle() {
 		var bezPts = MathUtils.circularArcToBezier( [0,0,0], [1,0,0], 2.0*Math.PI );
 		if (bezPts) {
 			var n = bezPts.length;
+            var gradient,
+                colors,
+                len,
+                j,
+                position,
+                cs,
+                c;
 
 			// set up the fill style
 			ctx.beginPath();
 			ctx.lineWidth = 0;
 			if (this._fillColor) {
-				var c = "rgba(" + 255*this._fillColor[0] + "," + 255*this._fillColor[1] + "," + 255*this._fillColor[2] + "," + this._fillColor[3] + ")";  
-				ctx.fillStyle = c;
-
+                if(this._fillColor.gradientMode) {
+                    if(this._fillColor.gradientMode === "radial") {
+                        gradient = ctx.createRadialGradient(xCtr, yCtr, 0,
+                                                            xCtr, yCtr, yScale);
+                    } else {
+                        gradient = ctx.createLinearGradient(0, this._height/2, this._width, this._height/2);
+                    }
+                    colors = this._fillColor.color;
+
+                    len = colors.length;
+
+                    for(j=0; j<len; j++) {
+                        position = colors[j].position/100;
+                        cs = colors[j].value;
+                        gradient.addColorStop(position, "rgba(" + cs.r + "," + cs.g + "," + cs.b + "," + cs.a + ")");
+                    }
+
+                    ctx.fillStyle = gradient;
+
+                } else {
+                    c = "rgba(" + 255*this._fillColor[0] + "," + 255*this._fillColor[1] + "," + 255*this._fillColor[2] + "," + this._fillColor[3] + ")";
+                    ctx.fillStyle = c;
+                }
 				// draw the fill
-				ctx.beginPath();
+//				ctx.beginPath();
 				var p = MathUtils.transformPoint( bezPts[0],   mat );
 				ctx.moveTo( p[0],  p[1] );
 				var index = 1;
@@ -504,9 +531,29 @@ var Circle = function GLCircle() {
 			ctx.beginPath();
 			ctx.lineWidth	= lineWidth;
 			if (this._strokeColor) {
-				var c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";  
-				ctx.strokeStyle = c;
-			
+                if(this._strokeColor.gradientMode) {
+                    if(this._strokeColor.gradientMode === "radial") {
+                        gradient = ctx.createRadialGradient(xCtr, yCtr, yScale,
+                                                            xCtr, yCtr, 0.5*this._height);
+                    } else {
+                        gradient = ctx.createLinearGradient(0, this._height/2, this._width, this._height/2);
+                    }
+                    colors = this._strokeColor.color;
+
+                    len = colors.length;
+
+                    for(j=0; j<len; j++) {
+                        position = colors[j].position/100;
+                        cs = colors[j].value;
+                        gradient.addColorStop(position, "rgba(" + cs.r + "," + cs.g + "," + cs.b + "," + cs.a + ")");
+                    }
+
+                    ctx.strokeStyle = gradient;
+
+                } else {
+                    c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";
+                    ctx.strokeStyle = c;
+                }
 				// draw the stroke
 				p = MathUtils.transformPoint( bezPts[0],   mat );
 				ctx.moveTo( p[0],  p[1] );
diff --git a/js/lib/geom/line.js b/js/lib/geom/line.js
index da63b21c..eaa26cf0 100755
--- a/js/lib/geom/line.js
+++ b/js/lib/geom/line.js
@@ -348,16 +348,46 @@ var Line = function GLLine( world, xOffset, yOffset, width, height, slope, strok
 		if (!ctx)  return;
 	
 		// set up the stroke style
-		var lineWidth = this._strokeWidth;
+		var lineWidth = this._strokeWidth,
+            w = this._width,
+            h = this._height;
+
+        var c,
+            gradient,
+            colors,
+            len,
+            n,
+            position,
+            cs;
+
 		ctx.beginPath();
 		ctx.lineWidth	= lineWidth;
 		if (this._strokeColor) {
-			var c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";  
-			ctx.strokeStyle = c;
+            if(this._strokeColor.gradientMode) {
+                if(this._strokeColor.gradientMode === "radial") {
+                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, h/2);
+                } else {
+                    gradient = ctx.createLinearGradient(0, h/2, w, h/2);
+                }
+                colors = this._strokeColor.color;
+
+                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 + ")");
+                }
+
+                ctx.strokeStyle = gradient;
+
+            } else {
+                c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";
+                ctx.strokeStyle = c;
+            }
 
 			// get the points
 			var p0,  p1;
-			var  w = this._width,  h = this._height;
 			if(this._slope === "vertical") {
 				p0 = [0.5*w, 0];
 				p1 = [0.5*w, h];
diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index d01d5b28..f13f624d 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -475,7 +475,7 @@ var Rectangle = function GLRectangle() {
 
             if(this._fillColor.gradientMode) {
                 if(this._fillColor.gradientMode === "radial") {
-                    gradient = ctx.createRadialGradient(w/2, h/2, h/2-inset, w/2, h/2, h-2*inset);
+                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, h/2-inset);
                 } else {
                     gradient = ctx.createLinearGradient(inset, h/2, w-2*inset, h/2);
                 }
@@ -509,7 +509,7 @@ var Rectangle = function GLRectangle() {
 
             if(this._strokeColor.gradientMode) {
                 if(this._strokeColor.gradientMode === "radial") {
-                    gradient = ctx.createRadialGradient(w/2, h/2, h/2, w/2, h/2, h);
+                    gradient = ctx.createRadialGradient(w/2, h/2, h/2-inset, w/2, h/2, h/2);
                 } else {
                     gradient = ctx.createLinearGradient(0, h/2, w, h/2);
                 }
-- 
cgit v1.2.3


From fcab2a14f8de302948d38f55db41e2c1c92baa34 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Thu, 8 Mar 2012 16:03:17 -0800
Subject: brush stroke options for calligraphic brush style

---
 js/lib/geom/brush-stroke.js | 147 +++++++++++++++++++++++++-------------------
 1 file changed, 84 insertions(+), 63 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 3e64e730..a92657a4 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -37,6 +37,8 @@ var BrushStroke = function GLBrushStroke() {
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
     this._strokeDoSmoothing = false;
+    this._strokeUseCalligraphic = false;
+    this._strokeAngle = 0;
 
     //the wetness of the brush (currently this is multiplied to the square of the stroke width, but todo should be changed to not depend on stroke width entirely
     //smaller value means more samples for the path
@@ -117,7 +119,7 @@ var BrushStroke = function GLBrushStroke() {
         //add the point only if it is some epsilon away from the previous point
         var numPoints = this._Points.length;
         if (numPoints>0) {
-            var threshold = 1;//this._WETNESS_FACTOR*this._strokeWidth;
+            var threshold = 2;//this._WETNESS_FACTOR*this._strokeWidth;
             var prevPt = this._Points[numPoints-1];
             var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
             var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
@@ -188,6 +190,14 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeDoSmoothing = s;
     }
 
+    this.setStrokeUseCalligraphic = function(c){
+        this._strokeUseCalligraphic = c;
+    }
+
+    this.setStrokeAngle = function(a){
+        this._strokeAngle = a;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -266,6 +276,8 @@ var BrushStroke = function GLBrushStroke() {
                     }
                 }
             }
+            //todo 4-point subdivision iterations over continuous regions of 'long' segments
+            // look at http://www.gvu.gatech.edu/~jarek/Split&Tweak/ for formula
             //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
             if (this._strokeDoSmoothing && numPoints>1) {
                 var numInsertedPoints = 0;
@@ -496,75 +508,84 @@ var BrushStroke = function GLBrushStroke() {
         }
         */
 
-        /*
-        //build the stamp for the brush stroke
-        //todo get this directly from the UI
-        var t=0;
-        var numTraces = this._strokeWidth;
-        var halfNumTraces = numTraces/2;
-        var startPos = [-this._strokeWidth/2,0];
-        var brushStamp = [];
-
-        //build an angled (calligraphic) brush stamp
-        var deltaDisplacement = [1,1];//[this._strokeWidth/numTraces, 0]; //a horizontal line brush
-        for (t=0;t<numTraces;t++){
-            var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
-            brushStamp.push(brushPt);
-        }
 
-        for (t=0;t<numTraces;t++){
-            var disp = [brushStamp[t][0], brushStamp[t][1]];
-            //ctx.globalCompositeOperation = 'source-over';
-            var distFromMiddle = Math.abs(halfNumTraces-t);
-            var alphaVal = 1.0 - (100-this._strokeHardness)*(distFromMiddle/halfNumTraces)/100;
-            alphaVal = 0.2;
-            ctx.save();
-            ctx.lineWidth=this._strokeWidth/10;//todo figure out the correct formula for the line width
-            if (ctx.lineWidth<2)
-                ctx.lineWidth=2;
-            if (t===numTraces-1){
-                ctx.lineWidth = 1;
-            }
-            ctx.lineJoin="bevel";
-            ctx.lineCap="butt";
-            //if (t<numTraces/2)
-                ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
-            //else
-            //    ctx.strokeStyle="rgba("+parseInt(255*this._secondStrokeColor[0])+","+parseInt(255*this._secondStrokeColor[1])+","+parseInt(255*this._secondStrokeColor[2])+","+alphaVal+")";
-            ctx.translate(disp[0],disp[1]);
-            ctx.beginPath();
-            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
-            for (var i=0;i<numPoints;i++){
-                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
-            }
-            ctx.stroke();
-            ctx.restore();
-        }
-        */
+        if (this._strokeUseCalligraphic) {
+            //build the stamp for the brush stroke
+            var t=0;
+            var numTraces = this._strokeWidth;
+            var halfNumTraces = numTraces/2;
+            var opaqueRegionHalfWidth = 0.5*this._strokeHardness*numTraces*0.01;
+            var maxTransparentRegionHalfWidth = halfNumTraces-opaqueRegionHalfWidth;
+            var startPos = [-this._strokeWidth/2,0];
+            var brushStamp = [];
 
+            //build an angled (calligraphic) brush stamp
+            var deltaDisplacement = [Math.cos(this._strokeAngle),Math.sin(this._strokeAngle)];
+            deltaDisplacement = VecUtils.vecNormalize(2, deltaDisplacement, 1);
 
-        var minStrokeWidth = (this._strokeHardness*this._strokeWidth)/100; //the hardness is the percentage of the stroke width that's fully opaque
-        var numlayers = 1 + (this._strokeWidth-minStrokeWidth)/2;
-        var alphaVal = 1.0/(numlayers);
-        ctx.lineCap = "round";
-        ctx.lineJoin="round";
-        ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
-        ctx.globalCompositeOperation = 'lighter'; //we wish to add up the colors
-        ctx.globalAlpha = this._strokeColor[3];
-        for (var l=0;l<numlayers;l++){
-            ctx.beginPath();
-            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
-            if (numPoints===1){
-               ctx.lineTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]+0.01);
+            for (t=0;t<numTraces;t++){
+                var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
+                brushStamp.push(brushPt);
             }
-            for (var i=1;i<numPoints;i++){
-                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+
+            for (t=0;t<numTraces;t++){
+                var disp = [brushStamp[t][0], brushStamp[t][1]];
+                //ctx.globalCompositeOperation = 'source-over';
+                var alphaVal = 1.0;
+                var distFromOpaqueRegion = Math.abs(t-halfNumTraces) - opaqueRegionHalfWidth;
+                if (distFromOpaqueRegion>0) {
+                    alphaVal = 1.0 - distFromOpaqueRegion/maxTransparentRegionHalfWidth;
+                }
+
+                ctx.save();
+                ctx.lineWidth=this._strokeWidth/10;//todo figure out the correct formula for the line width
+                if (ctx.lineWidth<2)
+                    ctx.lineWidth=2;
+                if (t===numTraces-1){
+                    ctx.lineWidth = 1;
+                }
+                ctx.lineJoin="bevel";
+                ctx.lineCap="butt";
+                ctx.globalAlpha = this._strokeColor[3];
+                
+                //if (t<numTraces/2)
+                    ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+                //else
+                //    ctx.strokeStyle="rgba("+parseInt(255*this._secondStrokeColor[0])+","+parseInt(255*this._secondStrokeColor[1])+","+parseInt(255*this._secondStrokeColor[2])+","+alphaVal+")";
+                ctx.translate(disp[0],disp[1]);
+                ctx.beginPath();
+                ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+                for (var i=0;i<numPoints;i++){
+                    ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+                }
+                ctx.stroke();
+                ctx.restore();
             }
+        } else {
 
-            ctx.lineWidth=2*l+minStrokeWidth;
-            ctx.stroke();
+            ctx.globalCompositeOperation = 'lighter'; //we wish to add up the colors
+            ctx.globalAlpha = this._strokeColor[3];
+            ctx.lineCap = "round";
+            ctx.lineJoin="round";
+            var minStrokeWidth = (this._strokeHardness*this._strokeWidth)/100; //the hardness is the percentage of the stroke width that's fully opaque
+            var numlayers = 1 + (this._strokeWidth-minStrokeWidth)/2;
+            var alphaVal = 1.0/(numlayers); //this way the alpha at the first path will be 1
+            ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+            for (var l=0;l<numlayers;l++){
+                ctx.beginPath();
+                ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+                if (numPoints===1){
+                    //display a tiny segment as a single point
+                   ctx.lineTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]+0.01);
+                }
+                for (var i=1;i<numPoints;i++){
+                    ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+                }
+                ctx.lineWidth=2*l+minStrokeWidth;
+                ctx.stroke();
+            }
         }
-
+        
         ctx.restore();
     }; //render()
 
-- 
cgit v1.2.3


From 7b6e8194b91168abdeb94702eb350d14f147858b Mon Sep 17 00:00:00 2001
From: hwc487
Date: Thu, 8 Mar 2012 17:29:18 -0800
Subject: Canvas IO

---
 js/lib/geom/circle.js    |  5 ++++-
 js/lib/geom/geom-obj.js  | 42 +++++++++++++++++++++++++++++++++++++++++-
 js/lib/geom/rectangle.js |  5 ++++-
 3 files changed, 49 insertions(+), 3 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index ad77383b..f94d4e6b 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -61,6 +61,8 @@ var Circle = function GLCircle() {
         } else {
 			this._fillMaterial = MaterialsModel.exportFlatMaterial();
         }
+
+		this.exportMaterials();
 	};
 
     ///////////////////////////////////////////////////////////////////////
@@ -610,8 +612,9 @@ var Circle = function GLCircle() {
 			console.log( "object material not found in library: " + fillMaterialName );
 			fillMat = MaterialsModel.exportFlatMaterial();
 		}
-
 		this._fillMaterial = fillMat;
+
+		this.importMaterials( importStr );
 	};
 
     this.collidesWithPoint = function( x, y ) {
diff --git a/js/lib/geom/geom-obj.js b/js/lib/geom/geom-obj.js
index 852aab89..1a197832 100755
--- a/js/lib/geom/geom-obj.js
+++ b/js/lib/geom/geom-obj.js
@@ -5,6 +5,27 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 </copyright> */
 
 var MaterialsModel = require("js/models/materials-model").MaterialsModel;
+var FlatMaterial = require("js/lib/rdge/materials/flat-material").FlatMaterial;
+var LinearGradientMaterial = require("js/lib/rdge/materials/linear-gradient-material").LinearGradientMaterial;
+var RadialGradientMaterial = require("js/lib/rdge/materials/radial-gradient-material").RadialGradientMaterial;
+var BumpMetalMaterial = require("js/lib/rdge/materials/bump-metal-material").BumpMetalMaterial;
+var UberMaterial = require("js/lib/rdge/materials/uber-material").UberMaterial;
+var RadialBlurMaterial = require("js/lib/rdge/materials/radial-blur-material").RadialBlurMaterial;
+var PlasmaMaterial = require("js/lib/rdge/materials/plasma-material").PlasmaMaterial;
+var PulseMaterial = require("js/lib/rdge/materials/pulse-material").PulseMaterial;
+var TunnelMaterial = require("js/lib/rdge/materials/tunnel-material").TunnelMaterial;
+var ReliefTunnelMaterial = require("js/lib/rdge/materials/relief-tunnel-material").ReliefTunnelMaterial;
+var SquareTunnelMaterial = require("js/lib/rdge/materials/square-tunnel-material").SquareTunnelMaterial;
+var FlyMaterial = require("js/lib/rdge/materials/fly-material").FlyMaterial;
+var WaterMaterial = require("js/lib/rdge/materials/water-material").WaterMaterial;
+var ZInvertMaterial = require("js/lib/rdge/materials/z-invert-material").ZInvertMaterial;
+var DeformMaterial = require("js/lib/rdge/materials/deform-material").DeformMaterial;
+var StarMaterial = require("js/lib/rdge/materials/star-material").StarMaterial;
+var TwistMaterial = require("js/lib/rdge/materials/twist-material").TwistMaterial;
+var JuliaMaterial = require("js/lib/rdge/materials/julia-material").JuliaMaterial;
+var KeleidoscopeMaterial = require("js/lib/rdge/materials/keleidoscope-material").KeleidoscopeMaterial;
+var MandelMaterial = require("js/lib/rdge/materials/mandel-material").MandelMaterial;
+
 ///////////////////////////////////////////////////////////////////////
 // Class GLGeomObj
 //      Super class for all geometry classes
@@ -235,7 +256,26 @@ var GeomObj = function GLGeomObj() {
 			var materialType = this.getPropertyFromString( "material: ",	importStr );
 			switch (materialType)
 			{
-				case "flat":		mat = new FlatMaterial();		break;
+				case "flat":			mat = new FlatMaterial();				break;
+				case "radialGradient":  mat = new RadialGradientMaterial();		break;
+				case "linearGradient":  mat = new LinearGradientMaterial();		break;
+				case "bumpMetal":		mat = new BumpMetalMaterial();			break;
+				case "uber":			mat = new UberMaterial();				break;
+				case "plasma":			mat = new PlasmaMaterial();				break;
+				case "deform":			mat = new DeformMaterial();				break;
+				case "water":			mat = new WaterMaterial();				break;
+				case "tunnel":			mat = new TunnelMaterial();				break;
+				case "reliefTunnel":	mat = new ReliefTunnelMaterial();		break;
+				case "squareTunnel":	mat = new SquareTunnelMaterial();		break;
+				case "twist":			mat = new TwiseMaterial();				break;
+				case "fly":				mat = new FlyMaterial();				break;
+				case "julia":			mat = new JuliaMaterial();				break;
+				case "mandel":			mat = new MandelMaterial();				break;
+				case "star":			mat = new StarMaterial();				break;
+				case "zinvert":			mat = new ZInvertMaterial();			break;
+				case "keleidoscope":	mat = new KeleidoscopeMaterial();		break;
+				case "radialBlur":		mat = new RadialBlurMaterial();			break;
+				case "pulse":			mat = new PulseMaterial();				break;
 
 				default:
 					console.log( "material type: " + materialType + " is not supported" );
diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index f91e830c..370bb257 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -79,6 +79,8 @@ var Rectangle = function GLRectangle() {
         } else {
 			this._fillMaterial = MaterialsModel.exportFlatMaterial();
         }
+
+		this.exportMaterials();
 	};
 
 	///////////////////////////////////////////////////////////////////////
@@ -264,8 +266,9 @@ var Rectangle = function GLRectangle() {
 			console.log( "object material not found in library: " + fillMaterialName );
 			fillMat = MaterialsModel.exportFlatMaterial();
 		}
-
 		this._fillMaterial = fillMat;
+
+		this.importMaterials( importStr );
 	};
 
 	this.buildBuffers = function() {
-- 
cgit v1.2.3


From 7793b312ef9490c90c3d2332849ab41d56950437 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Fri, 9 Mar 2012 10:28:40 -0800
Subject: Fixing radial gradients for line and circle.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/circle.js | 6 +++---
 js/lib/geom/line.js   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index 70f608be..8f9f54d1 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -457,7 +457,7 @@ var Circle = function GLCircle() {
                 if(this._fillColor.gradientMode) {
                     if(this._fillColor.gradientMode === "radial") {
                         gradient = ctx.createRadialGradient(xCtr, yCtr, 0,
-                                                            xCtr, yCtr, yScale);
+                                                            xCtr, yCtr, Math.max(yScale, xScale));
                     } else {
                         gradient = ctx.createLinearGradient(0, this._height/2, this._width, this._height/2);
                     }
@@ -533,8 +533,8 @@ var Circle = function GLCircle() {
 			if (this._strokeColor) {
                 if(this._strokeColor.gradientMode) {
                     if(this._strokeColor.gradientMode === "radial") {
-                        gradient = ctx.createRadialGradient(xCtr, yCtr, yScale,
-                                                            xCtr, yCtr, 0.5*this._height);
+                        gradient = ctx.createRadialGradient(xCtr, yCtr, Math.min(xScale, yScale),
+                                                            xCtr, yCtr, 0.5*Math.max(this._height, this._width));
                     } else {
                         gradient = ctx.createLinearGradient(0, this._height/2, this._width, this._height/2);
                     }
diff --git a/js/lib/geom/line.js b/js/lib/geom/line.js
index eaa26cf0..51a6fa98 100755
--- a/js/lib/geom/line.js
+++ b/js/lib/geom/line.js
@@ -365,7 +365,7 @@ var Line = function GLLine( world, xOffset, yOffset, width, height, slope, strok
 		if (this._strokeColor) {
             if(this._strokeColor.gradientMode) {
                 if(this._strokeColor.gradientMode === "radial") {
-                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, h/2);
+                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, Math.max(w/2, h/2));
                 } else {
                     gradient = ctx.createLinearGradient(0, h/2, w, h/2);
                 }
-- 
cgit v1.2.3


From 3f80251670e187377f9f8ae4547328c8bf344977 Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Fri, 9 Mar 2012 10:36:32 -0800
Subject: Fixing radial gradient for rectangle.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/geom/rectangle.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index f13f624d..81201a79 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -475,7 +475,7 @@ var Rectangle = function GLRectangle() {
 
             if(this._fillColor.gradientMode) {
                 if(this._fillColor.gradientMode === "radial") {
-                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, h/2-inset);
+                    gradient = ctx.createRadialGradient(w/2, h/2, 0, w/2, h/2, Math.max(w/2, h/2)-inset);
                 } else {
                     gradient = ctx.createLinearGradient(inset, h/2, w-2*inset, h/2);
                 }
@@ -509,7 +509,7 @@ var Rectangle = function GLRectangle() {
 
             if(this._strokeColor.gradientMode) {
                 if(this._strokeColor.gradientMode === "radial") {
-                    gradient = ctx.createRadialGradient(w/2, h/2, h/2-inset, w/2, h/2, h/2);
+                    gradient = ctx.createRadialGradient(w/2, h/2, Math.min(h/2, w/2)-inset, w/2, h/2, Math.max(h/2, w/2));
                 } else {
                     gradient = ctx.createLinearGradient(0, h/2, w, h/2);
                 }
-- 
cgit v1.2.3


From 00b1e6a9bed04172ad84bdd810f1bd999e8fa0eb Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Mon, 12 Mar 2012 15:02:07 -0700
Subject: bug fixes for spline interpolation

AND
Laplacian smoothing for denoising
AND
code cleanup (removing blocks of commented code)
---
 js/lib/geom/brush-stroke.js | 245 +++++++++++++++-----------------------------
 1 file changed, 81 insertions(+), 164 deletions(-)

(limited to 'js/lib/geom')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index a92657a4..595a6a63 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -32,7 +32,7 @@ var BrushStroke = function GLBrushStroke() {
     //stroke information
     this._strokeWidth = 0.0;
     this._strokeColor = [0.4, 0.4, 0.4, 1.0];
-    this._secondStrokeColor = this._strokeColor;
+    this._secondStrokeColor = [1, 0.4, 0.4, 1.0];
     this._strokeHardness = 100;
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
@@ -44,6 +44,12 @@ var BrushStroke = function GLBrushStroke() {
     //smaller value means more samples for the path
     this._WETNESS_FACTOR = 0.25;
 
+    //threshold that tells us whether two samples are too far apart
+    this._MAX_SAMPLE_DISTANCE_THRESHOLD = 5;
+
+    //threshold that tells us whether two samples are too close
+    this._MIN_SAMPLE_DISTANCE_THRESHOLD = 2;
+
     //prevent extremely long paths that can take a long time to render
     this._MAX_ALLOWED_SAMPLES = 500;
 
@@ -119,7 +125,7 @@ var BrushStroke = function GLBrushStroke() {
         //add the point only if it is some epsilon away from the previous point
         var numPoints = this._Points.length;
         if (numPoints>0) {
-            var threshold = 2;//this._WETNESS_FACTOR*this._strokeWidth;
+            var threshold = this._MIN_SAMPLE_DISTANCE_THRESHOLD;//this._WETNESS_FACTOR*this._strokeWidth;
             var prevPt = this._Points[numPoints-1];
             var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
             var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
@@ -276,13 +282,16 @@ var BrushStroke = function GLBrushStroke() {
                     }
                 }
             }
+
             //todo 4-point subdivision iterations over continuous regions of 'long' segments
             // look at http://www.gvu.gatech.edu/~jarek/Split&Tweak/ for formula
             //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
             if (this._strokeDoSmoothing && numPoints>1) {
                 var numInsertedPoints = 0;
-                var threshold = 5;//0.25*this._strokeWidth; //this determines whether a segment between two sample is too long
+                var newPoints = [];
+                var threshold = this._MAX_SAMPLE_DISTANCE_THRESHOLD;//this determines whether a segment between two sample is long enough to warrant checking for angle
                 var prevPt = this._Points[0];
+                newPoints.push(this._Points[0]);
                 for (var i=1;i<numPoints;i++){
                     var pt = this._Points[i];
                     var diff = [pt[0]-prevPt[0], pt[1]-prevPt[1]];
@@ -298,12 +307,14 @@ var BrushStroke = function GLBrushStroke() {
                             var param = (j+1)/(numNewPoints+1);
                             var newpt = this._CatmullRomSplineInterpolate(ctrlPts, param);
                             //insert new point before point i
-                            this._Points.splice(i, 0, newpt);
-                            i++;
+                            //this._Points.splice(i, 0, newpt);
+                            //i++;
+                            newPoints.push(newpt);
                             numInsertedPoints++;
                         }
                         this._dirty=true;
                     }
+                    newPoints.push(pt);
                     prevPt=pt;
                     //update numPoints to match the new length
                     numPoints = this._Points.length;
@@ -314,7 +325,22 @@ var BrushStroke = function GLBrushStroke() {
                         break;
                     }
                 }
+                this._Points = newPoints;
+                numPoints = this._Points.length;
                 console.log("Inserted "+numInsertedPoints+" additional CatmullRom points");
+
+                //now do 3-4 iterations of Laplacian smoothing (setting the points to the average of their neighbors)
+                var numLaplacianIterations = 3; //todo figure out the proper number of Laplacian iterations (perhaps as a function of stroke width)
+                for (var n=0;n<numLaplacianIterations;n++){
+                    newPoints = this._Points;
+                    for (var i=1;i<numPoints-1;i++){
+                        var avgPos = [  0.5*(this._Points[i-1][0] + this._Points[i+1][0]),
+                                        0.5*(this._Points[i-1][1] + this._Points[i+1][1]),
+