@armyc2.c5isr.renderer/mil-sym-ts-web 2.2.0

package/src/main/ts/armyc2/c5isr/renderer/shapes/arc.ts

@@ -0,0 +1,64 @@
+import { Rectangle } from "./rectangle";
+import { ShapeTypes } from "./types";
+
+export class Arc
+{
+
+    private x:number;
+    private y:number;
+    private r:number;
+    private sa:number;
+    private ea:number;
+    private rectangle:Rectangle;
+
+    constructor(x:number,y:number,r:number,sa:number,ea:number) 
+    {
+
+        this.x = x,
+        this.y = y,
+        this.r = r,
+        this.sa = sa * (Math.PI / 180),
+        this.ea = ea * (Math.PI / 180);
+        //not accurate, covers the whole circle, not just the arc.
+        this.rectangle = new Rectangle(x-r,y-r,r*2,r*2);
+    }
+
+    getShapeType():string
+    {
+        return ShapeTypes.ARC;
+    }
+
+    getBounds():Rectangle
+    {
+        return new Rectangle(this.rectangle.getX(),
+                                this.rectangle.getY(),
+                                this.rectangle.getWidth(),
+                                this.rectangle.getHeight());
+    }
+
+    
+    shift(x:number,y:number){
+        this.x +=x;
+        this.y +=y;
+        this.rectangle.shift(x,y);
+    }
+
+    setPath(context:CanvasRenderingContext2D){
+
+        //context.beginPath();
+        context.arc(this.x,this.y,this.r,this.sa,this.ea,false);//counter-clockwise=false
+
+    };
+    stroke(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.stroke();
+    };
+    fill(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.fill();
+    };
+
+}
+

package/src/main/ts/armyc2/c5isr/renderer/shapes/bcurve.ts

@@ -0,0 +1,95 @@
+import { Point } from "./point";
+import { Rectangle } from "./rectangle";
+
+export class BCurve
+{
+
+    private x1 = 0;
+    private y1 = 0;
+    private x2 = 0;
+    private y2 = 0;
+    private x3 = 0;
+    private y3 = 0;
+    private x4 = 0;
+    private y4 = 0;
+    private rectangle:Rectangle;
+
+    constructor(x1,y1,x2,y2,x3,y3,x4,y4) 
+    {
+
+    //will be larger than the actual curve.
+    this.rectangle = new Rectangle(x1,y1,1,1);
+    this.rectangle.unionPoint(new Point(x2,y2));
+    this.rectangle.unionPoint(new Point(x3,y3));
+    this.rectangle.unionPoint(new Point(x4,y4));
+
+    };
+	
+    getShapeType():string
+    {
+        return "BCURVE";//armyc2.c2sd.renderer.so.ShapeTypes.BCURVE;
+    }
+
+    getBounds():Rectangle{
+        return new Rectangle(this.rectangle.getX()-1,
+                                this.rectangle.getY()-1,
+                                this.rectangle.getWidth()+2,
+                                this.rectangle.getHeight()+2);
+    };
+
+    shift(x:number,y:number){
+        this.x1 += x;
+        this.y1 += y;
+        this.x2 += x;
+        this.y2 += y;
+        this.x3 += x;
+        this.y3 += y;
+        this.x4 += x;
+        this.y4 += y;
+        this.rectangle.shift(x,y);
+    };
+
+    setPath(context:CanvasRenderingContext2D){
+
+        //context.beginPath();
+        context.moveTo(this.x1,this.y1);
+        context.bezierCurveTo(this.x2,this.y2,this.x3,this.y3,this.x4,this.y4);//counter-clockwise=false
+
+    };
+    stroke(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.stroke();
+    };
+    fill(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.fill();
+    };
+    
+    toSVGElement(stroke:string | null, strokeWidth:number, fill:string | null):string
+    {
+        // Q400,50 600,300
+        let path = '<path d="M' + this.x1 + ' ' + this.y1;
+        path += "C" + this.x2 + " " + this.y2 + " " + this.x3 + " " + this.y3 + " " + this.x4 + " " + this.y4 + '"';
+                
+        if(stroke)
+            path += ' stroke="' + stroke + '"';
+        
+        if(strokeWidth)
+            path += ' stroke-width="' + (strokeWidth) + '"';
+        else if(stroke) 
+            path += ' stroke-width="2"';
+        
+                    
+        if(fill)
+            path += ' fill="' + fill + '"';
+        else
+            path += ' fill="none"';
+        
+        path += '/>';
+        return path;
+    };
+
+}
+

package/src/main/ts/armyc2/c5isr/renderer/shapes/ellipse.ts

@@ -0,0 +1,93 @@
+import { Rectangle } from "./rectangle";
+import { ShapeTypes } from "./types";
+
+export class Ellipse
+{
+    private rectangle:Rectangle
+
+    constructor(x:number,y:number,w:number,h:number) 
+    {
+        this.rectangle = new Rectangle(x,y,w,h);
+    }
+
+    getShapeType():string
+    {
+        return ShapeTypes.ELLIPSE;
+    }
+
+    getBounds():Rectangle
+    {
+        return new Rectangle(this.rectangle.getX()-1,
+                                this.rectangle.getY()-1,
+                                this.rectangle.getWidth()+2,
+                                this.rectangle.getHeight()+2);
+    }
+
+    shift(x:number,y:number){
+        this.rectangle.shift(x,y);
+    }
+
+    setPath(context:CanvasRenderingContext2D){
+        var x = this.rectangle.getX(),
+            y = this.rectangle.getY(),
+            w = this.rectangle.getWidth(),
+            h = this.rectangle.getHeight();
+
+        var kappa = 0.5522848,
+            ox = (w/2)*kappa,//control point offset horizontal
+            oy = (h/2)*kappa,//control point offset vertical
+            xe = x + w,      //x-end
+            ye = y + h,      //y-end
+            xm = x + w / 2,  //x-middle
+            ym = y + h / 2;  //y-middle
+
+        //context.beginPath();
+        context.moveTo(x,ym);
+        context.bezierCurveTo(x,ym-oy,xm-ox,y,xm,y);
+        context.bezierCurveTo(xm + ox,y,xe,ym - oy,xe,ym);
+        context.bezierCurveTo(xe,ym+oy,xm+ox,ye,xm,ye);
+        context.bezierCurveTo(xm-ox,ye,x,ym+oy,x,ym);
+        context.closePath();
+    }
+    stroke(context:CanvasRenderingContext2D):void
+    {
+        context.beginPath();
+        this.setPath(context);
+        context.stroke();
+    }
+    fill(context:CanvasRenderingContext2D):void
+    {
+        context.beginPath();
+        this.setPath(context);
+        context.fill();
+    }
+    toSVGElement(stroke:string | null, strokeWidth:number, fill:string | null):string
+    {
+        var cx = this.rectangle.getCenterX();
+        var cy = this.rectangle.getCenterY();
+        var rx = this.rectangle.getWidth()/2;
+        var ry = this.rectangle.getHeight()/2;
+        var line = '<ellipse cx="' + cx + '" cy="' + cy;
+        line += '" rx="' + rx + '" ry="' + ry + '"';
+        
+        if(strokeWidth)
+            line += ' stroke-width="' + strokeWidth + '"';
+        else if(stroke)
+            line += ' stroke-width="2"';
+        
+        if(stroke)
+            line += ' stroke="' + stroke + '"';
+            
+        if(fill)
+            line += ' fill="' + fill + '"';
+        else
+            line += ' fill="none"';    
+        
+        line += '/>';
+        return line;
+    };
+
+}
+
+
+    

package/src/main/ts/armyc2/c5isr/renderer/shapes/line.ts

@@ -0,0 +1,114 @@
+import { Point } from "./point";
+import { ShapeTypes } from "./types";
+import { Rectangle } from "./rectangle";
+import { ShapeUtilties } from "./utilities";
+
+
+export class Line
+{
+    private pt1:Point;
+    private pt2:Point;
+    private rectangle:Rectangle
+
+    constructor(x1:number,y1:number,x2:number,y2:number) {
+
+        this.pt1 = new Point(x1,y1);
+        this.pt2 = new Point(x2,y2);
+
+        this.rectangle = new Rectangle(x1,y1,1,1);
+        this.rectangle.unionPoint(new Point(x2,y2));            
+
+    };
+     
+    // <editor-fold defaultstate="collapsed" desc="Public Functions">
+    getShapeType(){
+        return ShapeTypes.LINE;
+    };
+
+    getBounds(){
+        return new Rectangle(this.rectangle.getX(),
+                                this.rectangle.getY(),
+                                this.rectangle.getWidth(),
+                                this.rectangle.getHeight());
+    };
+    getP1()
+    {
+        return this.pt1;
+    };
+    getP2()
+    {
+        return this.pt2;
+    };
+    
+    shift(x:number,y:number){
+
+        this.rectangle.shift(x,y);
+        
+        this.pt1.shift(x,y);
+        this.pt2.shift(x,y);
+
+    };
+        /**
+     * Tests if the specified line segment intersects this line segment.
+     * @param line the specified <code>Line</code>
+     * @return <code>true</code> if this line segment and the specified line
+     *			segment intersect each other; 
+     *			<code>false</code> otherwise.
+     */
+    intersectsLine(line:Line)
+    {
+        return ShapeUtilties.linesIntersect(
+                    this.getP1().getX(),this.getP1().getY(),
+                    this.getP2().getX(),this.getP2().getY(),
+                    line.getP1().getX(),line.getP1().getY(),
+                    line.getP2().getX(),line.getP2().getY());
+        
+    };
+
+
+    setPath(context:CanvasRenderingContext2D){
+
+        //context.beginPath();
+        context.moveTo(this.pt1.getX(),this.pt1.getY());
+        context.lineTo(this.pt2.getX(),this.pt2.getY());
+
+    };
+    stroke(context:CanvasRenderingContext2D){
+        context.beginPath();
+        context.moveTo(this.pt1.getX(),this.pt1.getY());
+        context.lineTo(this.pt2.getX(),this.pt2.getY());
+        context.stroke();
+    };
+    fill(context:CanvasRenderingContext2D){
+        context.beginPath();
+        context.moveTo(this.pt1.getX(),this.pt1.getY());
+        context.lineTo(this.pt2.getX(),this.pt2.getY());
+        context.fill();
+    };
+    
+    toSVGElement(stroke:string | null, strokeWidth:number, fill:string | null):string
+    {
+        var line = '<line x1="' + this.pt1.getX() + '" y1="' + this.pt1.getY();
+        line += '" x2="' + this.pt2.getX() + '" y2="' + this.pt2.getY() + '"';
+        
+        if(strokeWidth)
+            line += ' stroke-width="' + strokeWidth + '"';
+        else if(stroke) 
+            line += ' stroke-width="2"';
+        
+        if(stroke)
+            line += ' stroke="' + stroke + '"';
+            
+        if(fill)
+            line += ' fill="' + fill + '"';
+        else
+            line += ' fill="none"';
+        
+        line += '/>';
+        return line;
+    };
+}
+
+
+
+