agt 0.0.1

data/app/assets/javascripts/agt/geom/cubic_bezier.coffee

@@ -0,0 +1,37 @@
+namespace('agt.geom')
+
+# Public:
+class agt.geom.CubicBezier
+  @include agt.mixins.Formattable('CubicBezier')
+  @include agt.mixins.Sourcable('agt.geom.CubicBezier', 'vertices', 'bias')
+  @include agt.geom.Geometry
+  @include agt.geom.Path
+  @include agt.geom.Intersections
+  @include agt.geom.Spline(3)
+
+  ### Public ###
+
+  constructor: (vertices, bias=20) ->
+    @initSpline vertices, bias
+
+  pointInSegment: (t, seg) ->
+    pt = new agt.geom.Point()
+    pt.x = (seg[0].x * @b1 (t)) +
+           (seg[1].x * @b2 (t)) +
+           (seg[2].x * @b3 (t)) +
+           (seg[3].x * @b4 (t))
+    pt.y = (seg[0].y * @b1 (t)) +
+           (seg[1].y * @b2 (t)) +
+           (seg[2].y * @b3 (t)) +
+           (seg[3].y * @b4 (t))
+    pt
+
+  ### Internal ###
+
+  b1: (t) -> ((1 - t) * (1 - t) * (1 - t))
+
+  b2: (t) -> (3 * t * (1 - t) * (1 - t))
+
+  b3: (t) -> (3 * t * t * (1 - t))
+
+  b4: (t) -> (t * t * t)

data/app/assets/javascripts/agt/geom/diamond.coffee

@@ -0,0 +1,241 @@
+namespace('agt.geom')
+
+# Public:
+class agt.geom.Diamond
+  properties = ['topLength', 'rightLength', 'bottomLength', 'leftLength', 'x', 'y', 'rotation']
+
+  @include agt.mixins.Formattable(['Diamond'].concat(properties)...)
+  @include agt.mixins.Parameterizable('diamondFrom', {
+    topLength: 1
+    rightLength: 1
+    bottomLength: 1
+    leftLength: 1
+    x: 0
+    y: 0
+    rotation: 0
+  })
+  @include agt.mixins.Sourcable(['agt.geom.Diamond'].concat properties)
+  @include agt.mixins.Equatable(properties...)
+  @include agt.mixins.Cloneable()
+  @include agt.mixins.Memoizable
+  @include agt.geom.Geometry
+  @include agt.geom.Surface
+  @include agt.geom.Path
+  @include agt.geom.Intersections
+
+  ### Public ###
+
+  constructor: (topLength, rightLength, bottomLength, leftLength, x, y, rotation) ->
+    args = @diamondFrom topLength, rightLength, bottomLength, leftLength, x, y, rotation
+    {@topLength, @rightLength, @bottomLength, @leftLength, @x, @y, @rotation} = args
+
+  center: -> new agt.geom.Point(@x, @y)
+
+  topAxis: -> new agt.geom.Point(0,-@topLength).rotate(@rotation)
+
+  bottomAxis: -> new agt.geom.Point(0,@bottomLength).rotate(@rotation)
+
+  leftAxis: -> new agt.geom.Point(-@leftLength,0).rotate(@rotation)
+
+  rightAxis: -> new agt.geom.Point(@rightLength,0).rotate(@rotation)
+
+  corners: ->
+    [
+      @topCorner()
+      @rightCorner()
+      @bottomCorner()
+      @leftCorner()
+    ]
+
+  topCorner: -> @center().add(@topAxis())
+
+  bottomCorner: -> @center().add(@bottomAxis())
+
+  leftCorner: -> @center().add(@leftAxis())
+
+  rightCorner: -> @center().add(@rightAxis())
+
+  edges: ->
+    [
+      @topLeftEdge()
+      @topRightEdge()
+      @bottomRightEdge()
+      @bottomLeftEdge()
+    ]
+
+  topLeftEdge: -> @topCorner().subtract(@leftCorner())
+
+  topRightEdge: -> @rightCorner().subtract(@topCorner())
+
+  bottomLeftEdge: -> @leftCorner().subtract(@bottomCorner())
+
+  bottomRightEdge: -> @bottomCorner().subtract(@rightCorner())
+
+  quadrants: ->
+    [
+      @topLeftQuadrant()
+      @topRightQuadrant()
+      @bottomRightQuadrant()
+      @bottomLeftQuadrant()
+    ]
+
+  topLeftQuadrant: ->
+    k = 'topLeftQuadrant'
+    return @memoFor k if @memoized k
+    @memoize k, new agt.geom.Triangle(@center(), @topCorner(), @leftCorner())
+
+  topRightQuadrant: ->
+    k = 'topRightQuadrant'
+    return @memoFor k if @memoized k
+    @memoize k, new agt.geom.Triangle(@center(), @topCorner(), @rightCorner())
+
+  bottomLeftQuadrant: ->
+    k = 'bottomLeftQuadrant'
+    return @memoFor k if @memoized k
+    @memoize k, new agt.geom.Triangle(@center(), @bottomCorner(), @leftCorner())
+
+  bottomRightQuadrant: ->
+    k = 'bottomRightQuadrant'
+    return @memoFor k if @memoized k
+    @memoize k, new agt.geom.Triangle(@center(), @bottomCorner(), @rightCorner())
+
+  top: -> Math.min @topCorner().y,
+                   @bottomCorner().y,
+                   @leftCorner().y,
+                   @rightCorner().y,
+
+  bottom: -> Math.max @topCorner().y,
+                      @bottomCorner().y,
+                      @leftCorner().y,
+                      @rightCorner().y,
+
+  left: -> Math.min @topCorner().x,
+                    @bottomCorner().x,
+                    @leftCorner().x,
+                    @rightCorner().x,
+
+  right: -> Math.max @topCorner().x,
+                     @bottomCorner().x,
+                     @leftCorner().x,
+                     @rightCorner().x,
+
+  translate: (xOrPt, y) ->
+    {x,y} = agt.geom.Point.pointFrom xOrPt, y
+
+    @x += x
+    @y += y
+    this
+
+  rotate: (rotation) ->
+    @rotation += rotation
+    this
+
+  scale: (scale) ->
+    @topLength *= scale
+    @bottomLength *= scale
+    @rightLength *= scale
+    @leftLength *= scale
+    this
+
+  points: ->
+    [t = @topCorner(), @rightCorner(), @bottomCorner(), @leftCorner(), t]
+
+  triangles: -> @quadrants()
+
+  closedGeometry: -> true
+
+  pointAtAngle: (angle) ->
+    center = @center()
+    vec = center.add Math.cos(angle)*10000,
+                     Math.sin(angle)*10000
+    @intersections(points: -> [center, vec])?[0]
+
+  acreage: ->
+    @topLeftQuadrant().acreage() +
+    @topRightQuadrant().acreage() +
+    @bottomLeftQuadrant().acreage() +
+    @bottomRightQuadrant().acreage()
+
+  contains: (x,y) ->
+    @center().equals(x,y) or
+    @topLeftQuadrant().contains(x,y) or
+    @topRightQuadrant().contains(x,y) or
+    @bottomLeftQuadrant().contains(x,y) or
+    @bottomRightQuadrant().contains(x,y)
+
+  randomPointInSurface: (random) ->
+    l = @acreage()
+    q1 = @topLeftQuadrant()
+    q2 = @topRightQuadrant()
+    q3 = @bottomRightQuadrant()
+    q4 = @bottomLeftQuadrant()
+
+    a1 = q1.acreage()
+    a2 = q2.acreage()
+    a3 = q3.acreage()
+    a4 = q4.acreage()
+    a = a1 + a2 + a3 + a4
+
+    l1 = a1 / a
+    l2 = a2 / a
+    l3 = a3 / a
+    l4 = a4 / a
+
+    n = random.get()
+
+    if n < l1
+      q1.randomPointInSurface random
+    else if n < l1 + l2
+      q2.randomPointInSurface random
+    else if n < l1 + l2 + l3
+      q3.randomPointInSurface random
+    else
+      q4.randomPointInSurface random
+
+  length: ->
+    @topRightEdge().length() +
+    @topLeftEdge().length() +
+    @bottomRightEdge().length() +
+    @bottomLeftEdge().length()
+
+  pathPointAt: (n, pathBasedOnLength=true) ->
+    [p1,p2,p3] = @pathSteps pathBasedOnLength
+
+    if n < p1
+      @topCorner().add @topRightEdge().scale Math.map n, 0, p1, 0, 1
+    else if n < p2
+      @rightCorner().add @bottomRightEdge().scale Math.map n, p1, p2, 0, 1
+    else if n < p3
+      @bottomCorner().add @bottomLeftEdge().scale Math.map n, p2, p3, 0, 1
+    else
+      @leftCorner().add @topLeftEdge().scale Math.map n, p3, 1, 0, 1
+
+  pathOrientationAt: (n, pathBasedOnLength=true) ->
+    [p1,p2,p3] = @pathSteps pathBasedOnLength
+
+    if n < p1
+      p = @topRightEdge()
+    else if n < p2
+      p = @bottomRightEdge()
+    else if n < p3
+      p = @bottomLeftEdge().scale -1
+    else
+      p = @topLeftEdge().scale -1
+
+    p.angle()
+
+  pathSteps: (pathBasedOnLength=true) ->
+    if pathBasedOnLength
+      l = @length()
+      p1 = @topRightEdge().length() / l
+      p2 = p1 + @bottomRightEdge().length() / l
+      p3 = p2 + @bottomLeftEdge().length() / l
+    else
+      p1 = 1 / 4
+      p2 = 1 / 2
+      p3 = 3 / 4
+
+    [p1, p2, p3]
+
+  memoizationKey: ->
+    "#{@x};#{@y};#{@rotation};#{@topLength};#{@bottomLength};#{@leftLength};#{@rightLength};"

data/app/assets/javascripts/agt/geom/ellipsis.coffee

@@ -0,0 +1,141 @@
+namespace('agt.geom')
+
+# Public:
+class agt.geom.Ellipsis
+  properties = ['radius1', 'radius2', 'x', 'y', 'rotation', 'segments']
+
+  @include agt.mixins.Equatable(properties...)
+  @include agt.mixins.Formattable(['Ellipsis'].concat(properties)...)
+  @include agt.mixins.Parameterizable('ellipsisFrom', {
+    radius1: 1
+    radius2: 1
+    x: 0
+    y: 0
+    rotation: 0
+    segments: 36
+  })
+  @include agt.mixins.Sourcable(['agt.geom.Ellipsis'].concat(properties)...)
+  @include agt.mixins.Cloneable()
+  @include agt.mixins.Memoizable
+  @include agt.geom.Geometry
+  @include agt.geom.Surface
+  @include agt.geom.Path
+  @include agt.geom.Intersections
+
+  ### Public ###
+
+  constructor: (r1, r2, x, y, rot, segments) ->
+    {@radius1,@radius2,@x,@y,@rotation,@segments} = @ellipsisFrom r1, r2,
+                                                                  x, y, rot,
+                                                                  segments
+
+  center: -> new agt.geom.Point @x, @y
+
+  left: -> Math.min.apply Math, @xBounds()
+
+  right: -> Math.max.apply Math, @xBounds()
+
+  bottom: -> Math.max.apply Math, @yBounds()
+
+  top: -> Math.min.apply Math, @yBounds()
+
+  # Internal:
+  xBounds: ->
+    phi = @rotation
+    t = Math.atan(-@radius2 * Math.tan(phi) / @radius1)
+    [t, t+Math.PI].map (t) =>
+      @x + @radius1*Math.cos(t)*Math.cos(phi) -
+           @radius2*Math.sin(t)*Math.sin(phi)
+
+  # Internal:
+  yBounds: ->
+    phi = @rotation
+    t = Math.atan(@radius2 * (Math.cos(phi) / Math.sin(phi)) / @radius1)
+    [t, t+Math.PI].map (t) =>
+      @y + @radius1*Math.cos(t)*Math.sin(phi) +
+           @radius2*Math.sin(t)*Math.cos(phi)
+
+  translate: (xOrPt, y) ->
+    {x,y} = agt.geom.Point.pointFrom xOrPt, y
+
+    @x += x
+    @y += y
+    this
+
+  rotate: (rotation) ->
+    @rotation += rotation
+    this
+
+  scale: (scale) ->
+    @radius1 *= scale
+    @radius2 *= scale
+    this
+
+  points: ->
+    @memoFor('points').concat() if @memoized 'points'
+    @memoize 'points', (@pathPointAt n / @segments for n in [0..@segments])
+
+  triangles: ->
+    return @memoFor 'triangles' if @memoized 'triangles'
+
+    triangles = []
+    points = @points()
+    center = @center()
+    for i in [1..points.length-1]
+      triangles.push new agt.geom.Triangle center, points[i-1], points[i]
+
+    @memoize 'triangles', triangles
+
+  closedGeometry: -> true
+
+  pointAtAngle: (angle) ->
+    a = angle - @rotation
+    ratio = @radius1 / @radius2
+    vec = new agt.geom.Point Math.cos(a) * @radius1, Math.sin(a) * @radius1
+    vec.x = vec.x / ratio if @radius1 < @radius2
+    vec.y = vec.y * ratio if @radius1 > @radius2
+    a = vec.angle()
+    p = new agt.geom.Point Math.cos(a) * @radius1, Math.sin(a) * @radius2
+
+    @center().add p.rotate(@rotation)
+
+  acreage: -> Math.PI * @radius1 * @radius2
+
+  randomPointInSurface: (random) ->
+    unless random?
+      random = new agt.random.Random new agt.random.MathRandom
+
+    pt = @pathPointAt random.get()
+    center = @center()
+    dif = pt.subtract center
+    center.add dif.scale Math.sqrt random.random()
+
+  contains: (xOrPt, y) ->
+    p = new agt.geom.Point xOrPt, y
+    c = @center()
+    d = p.subtract c
+    a = d.angle()
+    p2 = @pointAtAngle a
+    c.distance(p2) >= c.distance(p)
+
+  length: -> Math.PI * (3*(@radius1 + @radius2) -
+             Math.sqrt((3* @radius1 + @radius2) * (@radius1 + @radius2 *3)))
+
+  pathPointAt: (n) ->
+    a = n * Math.PI * 2
+    p = new agt.geom.Point Math.cos(a) * @radius1, Math.sin(a) * @radius2
+
+    @center().add p.rotate(@rotation)
+
+  drawPath: (context) ->
+    context.save()
+    context.translate(@x, @y)
+    context.rotate(@rotation)
+    context.scale(@radius1, @radius2)
+    context.beginPath()
+    context.arc(0,0,1,0, Math.PI*2)
+    context.closePath()
+    context.restore()
+
+  memoizationKey: ->
+    "#{@radius1};#{@radius2};#{@x};#{@y};#{@rotation};#{@segments}"

data/app/assets/javascripts/agt/geom/linear_spline.coffee

@@ -0,0 +1,56 @@
+namespace('agt.geom')
+
+# Public: The `LinearSpline` is the simplest spline you can find.
+#
+# <script>window.exampleKey = 'linear_spline'</script>
+# <script>drawGeometry(exampleKey, {highlight: true})</script>
+#
+# ### Included Mixins
+#
+# - {agt.geom.Geometry}
+# - {agt.geom.Intersections}
+# - {agt.geom.Path}
+# - [agt.mixins.Spline](../../../files/geom/mixins/spline.coffee.html)
+# - [agt.mixins.Formattable](../../../files/mixins/formattable.coffee.html)
+# - [agt.mixins.Memoizable](../../../files/mixins/memoizable.coffee.html)
+# - [agt.mixins.Sourcable](../../../files/mixins/sourcable.coffee.html)
+class agt.geom.LinearSpline
+  @include agt.mixins.Formattable('LinearSpline')
+  @include agt.mixins.Sourcable('agt.geom.LinearSpline', 'vertices', 'bias')
+  @include agt.geom.Geometry
+  @include agt.geom.Path
+  @include agt.geom.Intersections
+  @include agt.geom.Spline(1)
+
+  ### Public ###
+
+  # Creates a new [LinearSpline]{agt.geom.LinearSpline}
+  #
+  # vertices - An {Array} of [Points]{agt.geom.Point} that forms the spline.
+  constructor: (vertices) ->
+    @initSpline vertices
+
+  # The points of a linear spline are the same as its array of vertices.
+  #
+  # <script>drawGeometryPoints(exampleKey, 'points')</script>
+  #
+  # Returns an {Array} of [Points]{agt.geom.Point}.
+  points: -> vertex.clone() for vertex in @vertices
+
+  # Returns the number of segments in the spline.
+  #
+  # Returns a {Number}
+  segments: -> @vertices.length - 1
+
+  # **Unsupported** - As the final points of a linear spine are its vertices
+  # there's no need to render the connections between them.
+  drawVerticesConnections: ->
+
+  ### Internal ###
+
+  # Validates the size of the vertices array.
+  #
+  # vertices - The {Array} of vertices to validate.
+  #
+  # Returns a {Boolean}.
+  validateVertices: (vertices) -> vertices.length >= 2