agt 0.0.1

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

@@ -0,0 +1,240 @@
+namespace('agt.geom')
+
+# Public: The Matrix class represents a transformation matrix that
+# determines how to map points from one coordinate space to another.
+# These transformation functions include translation (x and
+# y repositioning), rotation, scaling, and skewing.
+#
+# A matrix can created with the following signature:
+#
+# ```coffeescript
+# matrix = new Matrix
+#
+# matrix = new Matrix a, b, c, d, tx, ty
+#
+# matrix = new Matrix {a, b, c, d, tx, ty}
+# ```
+#
+# An identity matrix is created if no arguments is provided.
+class agt.geom.Matrix
+
+  # A list of the proprties to be checked to consider an object as a matrix.
+  properties = ['a', 'b', 'c', 'd', 'tx', 'ty']
+
+  @include agt.mixins.Equatable(properties...)
+  @include agt.mixins.Formattable(['Matrix'].concat(properties)...)
+  @include agt.mixins.Sourcable(['agt.geom.Matrix'].concat(properties)...)
+  @include agt.mixins.Parameterizable('matrixFrom', {
+    a: 1
+    b: 0
+    c: 0
+    d: 1
+    tx: 0
+    ty: 0
+  })
+  @include agt.mixins.Cloneable()
+
+  ### Public ###
+
+  # Returns `true` if the passed-in object `m` is a valid matrix.
+  # A valid matrix is an object with properties `a`, `b`, `c`, `d`,
+  # `tx` and `ty` and that properties must contains numbers.
+  #
+  # ```coffeescript
+  # Matrix.isMatrix new Matrix # true
+  #
+  # matrix2 = {
+  #   a: 1, b: 0, tx: 0,
+  #   c: 0, d: 1, ty: 0
+  # }
+  # Matrix.isMatrix matrix # true
+  #
+  # matrix2 = {
+  #   a: '1', b: '0', tx: '0',
+  #   c: '0', d: '1', ty: '0'
+  # }
+  # Matrix.isMatrix matrix # true
+  #
+  # Matris.isMatrix {} # false
+  # ```
+  @isMatrix: (m) ->
+    return false unless m?
+    return false for k in PROPERTIES when not Math.isFloat m[k]
+    true
+
+  # Creates a new Matrix instance.
+  #
+  # a  - The {Number} of the `a` property of the matrix
+  #      or a Matrix-like {Object}.
+  # b  - The {Number} of the `b` property of the matrix.
+  # c  - The {Number} of the `c` property of the matrix.
+  # d  - The {Number} of the `d` property of the matrix.
+  # tx - The {Number} of the `tx` property of the matrix.
+  # ty - The {Number} of the `ty` property of the matrix.
+  constructor: (a=1, b=0, c=0, d=1, tx=0, ty=0) ->
+    {@a, @b, @c, @d, @tx, @ty} = @matrixFrom a, b, c, d, tx, ty, true
+
+  # Returns a new point corresponding to the transformation
+  # of the passed-in point by the current matrix.
+  #
+  # ```coffeescript
+  # point = new Point 10, 0
+  #
+  # matrix = new Matrix().scale(2,2).rotate(90)
+  #
+  # projected = matrix.transformPoint point
+  # # projected = [object Point(0,20)]
+  # ```
+  #
+  # x - A {Number} for the x coordinate or a point-like {Object}.
+  # y - A {Number} for the y coordinate if the first argument
+  #     was also a number.
+  #
+  # Returns a new transformed [Point]{agt.geom.Point}.
+  transformPoint: (x, y) ->
+    if not x? and not y?
+      throw new Error "transformPoint was called without arguments"
+
+    {x,y} = agt.geom.Point.pointFrom x, y, true
+    new agt.geom.Point x*@a + y*@c + @tx,
+                       x*@b + y*@d + @ty
+
+  # Translates the matrix by the amount of the passed-in point.
+  #
+  # x - A {Number} for the x translation or a point-like {Object}.
+  # y - A {Number} for the y translation if the first argument
+  #     was also a number.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  translate: (x=0, y=0) ->
+    {x,y} = agt.geom.Point.pointFrom x, y
+
+    @tx += x
+    @ty += y
+    this
+
+  # Scales the matrix by the amount of the passed-in point.
+  #
+  # x - A {Number} for the x scale or a point-like {Object}.
+  # y - A {Number} for the y scale if the first argument
+  #     was also a number.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  scale: (x=1, y=1) ->
+    {x,y} = agt.geom.Point.pointFrom x, y
+
+    @a *= x
+    @d *= y
+    @tx *= x
+    @ty *= y
+    this
+
+  # Rotates the matrix by the amount of the passed-in angle in degrees.
+  #
+  # angle - The angle {Number} in radians.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  rotate: (angle=0) ->
+    cos = Math.cos angle
+    sin = Math.sin angle
+    [@a, @b, @c, @d, @tx, @ty] = [
+       @a*cos - @b*sin
+       @a*sin + @b*cos
+       @c*cos - @d*sin
+       @c*sin + @d*cos
+      @tx*cos - @ty*sin
+      @tx*sin + @ty*cos
+    ]
+    this
+
+  # Skews the matrix by the amount of the passed-in point.
+  #
+  # x - A {Number} for the x skew or a point-like {Object}.
+  # y - A {Number} for the y skew if the first argument
+  #     was also a number.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  skew: (x, y) ->
+    pt = agt.geom.Point.pointFrom(x, y, 0)
+    @append Math.cos(pt.y),
+            Math.sin(pt.y),
+            -Math.sin(pt.x),
+            Math.cos(pt.x)
+    this
+
+  # Append the passed-in matrix to this matrix.
+  #
+  # a  - The {Number} of the `a` property of the matrix to append
+  #      or a Matrix-like {Object}.
+  # b  - The {Number} of the `b` property of the matrix to append.
+  # c  - The {Number} of the `c` property of the matrix to append.
+  # d  - The {Number} of the `d` property of the matrix to append.
+  # tx - The {Number} of the `tx` property of the matrix to append.
+  # ty - The {Number} of the `ty` property of the matrix to append.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  append: (a=1, b=0, c=0, d=1, tx=0, ty=0) ->
+    {a, b, c, d, tx, ty} = @matrixFrom a, b, c, d, tx, ty, true
+    [@a, @b, @c, @d, @tx, @ty] = [
+       a*@a + b*@c
+       a*@b + b*@d
+       c*@a + d*@c
+       c*@b + d*@d
+      tx*@a + ty*@c + @tx
+      tx*@b + ty*@d + @ty
+    ]
+    this
+
+  # Prepend the passed-in matrix with this matrix.
+  #
+  # a  - The {Number} of the `a` property of the matrix to prepend
+  #      or a Matrix-like {Object}.
+  # b  - The {Number} of the `b` property of the matrix to prepend.
+  # c  - The {Number} of the `c` property of the matrix to prepend.
+  # d  - The {Number} of the `d` property of the matrix to prepend.
+  # tx - The {Number} of the `tx` property of the matrix to prepend.
+  # ty - The {Number} of the `ty` property of the matrix to prepend.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  prepend: (a=1, b=0, c=0, d=1, tx=0, ty=0) ->
+    {a, b, c, d, tx, ty} = @matrixFrom a, b, c, d, tx, ty, true
+    if a isnt 1 or b isnt 0 or c isnt 0 or d isnt 1
+      [@a, @b, @c, @d] = [
+        @a*a + @b*c
+        @a*b + @b*d
+        @c*a + @d*c
+        @c*b + @d*d
+      ]
+
+    [@tx, @ty] = [
+      @tx*a + @ty*c + tx
+      @tx*b + @ty*d + ty
+    ]
+    this
+
+  # Converts this matrix into an identity matrix.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  identity: -> [@a, @b, @c, @d, @tx, @ty] = [1, 0, 0, 1, 0, 0]; this
+
+  # Converts this matrix into its inverse.
+  #
+  # Returns this [Matrix]{agt.geom.Matrix}.
+  inverse: ->
+    n = @a * @d - @b * @c
+    [@a, @b, @c, @d, @tx, @ty] = [
+       @d / n
+      -@b / n
+      -@c / n
+       @a / n
+       (@c*@ty - @d*@tx) / n
+      -(@a*@ty - @b*@tx) / n
+    ]
+    this
+
+  # Alias the `Matrix.isMatrix` method in instances.
+  #
+  # m - An {Object} to test for matrix properties.
+  #
+  # Returns a {Boolean}.
+  isMatrix: (m) -> Matrix.isMatrix m

data/app/assets/javascripts/agt/geom/mixins/geometry.coffee

@@ -0,0 +1,171 @@
+namespace('agt.geom')
+# Public: The `Geometry` mixin describes the most basic interface a geometry
+# should implements.
+#
+# ```coffeescript
+# class DummyGeometry
+#   @include agt.geom.Geometry
+#
+#   # Your geometry implementation...
+# ```
+#
+# ### Shape
+#
+# <script>window.exampleKey = 'geometry'</script>
+# <script>drawGeometryPoints(exampleKey, 'points')</script>
+#
+# A geometry has a shape constituted by an {Array} of [Points]{agt.geom.Point}.
+# These points can be accessed using the {::points} method
+#
+# A geometry can be either opened or closed. It can be retrieved using
+# the {::closedGeometry} method.
+#
+# ### Bounds
+#
+# <script>drawGeometry(exampleKey, {bounds: true})</script>
+#
+# A geometry has bounds, represented by the {::left}, {::right}, {::top}
+# and {::bottom} methods. An object with the bounds value can be retrieved
+# using the {::bounds} method, and the [Rectangle]{agt.geom.Rectangle} formed
+# by the geometry bounds can be retrieved using the {::boundingBox} method.
+#
+# The default bounds computation consist in looking for every points
+# of the geometry shape and detect the minimal and maximal values
+# on each axis.
+# Generally the concrete geometry classes override the bounds methods
+# to provide a faster implementation.
+#
+# ### Drawing API
+#
+# <script>drawGeometry(exampleKey, {highlight: true})</script>
+#
+# Every geometry provides basic methods to draw themselves on a canvas,
+# {::stroke} and {::fill}, the latter renders a line when the former
+# renders a plain shape.
+#
+# Behind the hood, these two methods relies on the {::drawPath} method that
+# actually draw the shape in the canvas context. You can just override this
+# method when you need to draw the shape in a specific way.
+class agt.geom.Geometry
+
+  ### Public ###
+
+  # Abstract: Returns an {Array} of [Points]{agt.geom.Point}
+  # constituting the geometry.
+  #
+  # Closed geometry should always returns an array where the start and end
+  # values are equals.
+  #
+  # <script>drawGeometryPoints(exampleKey, 'points')</script>
+  #
+  # Returns an {Array} of [Points]{agt.geom.Point}.
+  points: ->
+
+  # Abstract: Returns a {Boolean} of whether the points forms
+  # a closed geometry.
+  #
+  # Returns a {Boolean}.
+  closedGeometry: -> false
+
+  # Internal: The `pointsBounds` private utility is meant to provide
+  # the default bounds computation for a geometry, subclasses should
+  # implements their own bounds methods if a faster implementation exist.
+  pointsBounds = (points, mode, axis) ->
+    Math[mode].apply Math, points.map (pt) -> pt[axis]
+
+  # Returns the top-most coordinate of the geometry shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'top')</script>
+  #
+  # Returns a {Number}.
+  top: -> pointsBounds @points(), 'min', 'y'
+
+  # Returns the bottom-most coordinate of the geometry shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'bottom')</script>
+  #
+  # Returns a {Number}.
+  bottom: -> pointsBounds @points(), 'max', 'y'
+
+  # Returns the left-most coordinate of the geometry shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'left')</script>
+  #
+  # Returns a {Number}.
+  left: -> pointsBounds @points(), 'min', 'x'
+
+  # Returns the right-most coordinate of the geometry shape.
+  #
+  # <script>drawGeometryBound(exampleKey, 'right')</script>
+  #
+  # Returns a {Number}.
+  right: -> pointsBounds @points(), 'max', 'x'
+
+  # Returns an {Object} containing the bounds of the object.
+  #
+  # <script>drawGeometry(exampleKey, {bounds: true})</script>
+  #
+  # Returns an {Object} with the following properties:
+  # :top - The {Number} for the shape upper bound.
+  # :bottom - The {Number} for the shape lower bound.
+  # :left - The {Number} for the shape left bound.
+  # :right - The {Number} for the shape right bound.
+  bounds: ->
+    top: @top()
+    left: @left()
+    right: @right()
+    bottom: @bottom()
+
+  # Returns a [Rectangle]{agt.geom.Rectangle} corresponding to the bounds
+  # of the current geometry.
+  #
+  # <script>drawGeometry(exampleKey, {bounds: true})</script>
+  #
+  # Returns a [Rectangle]{agt.geom.Rectangle}.
+  boundingBox: ->
+    new agt.geom.Rectangle(
+      @left(),
+      @top(),
+      @right() - @left(),
+      @bottom() - @top()
+    )
+
+  # Paints the geometry shape in the specified canvas `context` as a line.
+  #
+  # <script>drawGeometry(exampleKey, {stroke: 'highlight'})</script>
+  #
+  # context - The canvas context into which draw the geometry.
+  # color - The {String} color of the stroke.
+  stroke: (context, color=agt.COLORS.STROKE) ->
+    return unless context?
+
+    context.strokeStyle = color
+    @drawPath context
+    context.stroke()
+
+  # Paints the geometry shape in the specified canvas `context`
+  # as a plain shape.
+  #
+  # <script>drawGeometry(exampleKey, {fill: 'highlight'})</script>
+  #
+  # context - The canvas context into which draw the geometry.
+  # color - The {String} color of the fill.
+  fill: (context, color=agt.COLORS.FILL) ->
+    return unless context?
+
+    context.fillStyle = color
+    @drawPath context
+    context.fill()
+
+  # Draws the current geometry into the passed-in canvas `context`.
+  # That method only implements creating the geometry path using
+  # canvas methods.
+  #
+  # context - The canvas context into which draw the geometry.
+  drawPath: (context) ->
+    points = @points()
+    start = points.shift()
+    context.beginPath()
+    context.moveTo(start.x,start.y)
+    context.lineTo(p.x,p.y) for p in points
+    context.closePath()

data/app/assets/javascripts/agt/geom/mixins/intersections.coffee

@@ -0,0 +1,150 @@
+namespace('agt.geom')
+# Public: The `Intersections` mixin provides methods to geometries that
+# allow to compute intersections with other geometries.
+#
+# The default intersections computation implies testing all segments formed
+# by the `points` array returned by both geometries.
+#
+# The mixin also provides methods to register faster routines when one
+# is available for a given kind of geometry. For instance, when computing
+# intersections between a [Circle]{agt.geom.Circle} and another geometry
+# the {agt.geom.Circle::eachIntersections} method wil be used instead.
+# <script>window.exampleKey = 'geometry'</script>
+class agt.geom.Intersections
+  @iterators: {}
+
+  ### Public ###
+
+  # Returns `true` if the passed-in geometry intersects the current geometry.
+  #
+  # <script>drawIntersectsGeometry(exampleKey)</script>
+  #
+  # geometry - The [Geometry]{agt.geom.Geometry} to test.
+  #
+  # Returns a {Boolean} of whether the two geometries intersects.
+  intersects: (geometry) ->
+    return false if geometry.bounds? and not @boundsCollide geometry
+    output = false
+    iterator = @intersectionsIterator this, geometry
+    iterator.call this, this, geometry, -> output = true
+
+    output
+
+  # Returns an {Array} of all the intersections [Points]{agt.geom.Point} with
+  # the passed-in geometry. If there's no intersections the function returns
+  # `null`.
+  #
+  # <script>drawShapeIntersections(exampleKey, exampleKey)</script>
+  #
+  # geometry - The [Geometry]{agt.geom.Geometry} to test.
+  #
+  # Returns an {Array} of [Points]{agt.geom.Point}.
+  intersections: (geometry) ->
+    return null if geometry.bounds? and not @boundsCollide geometry
+    output = []
+    iterator = @intersectionsIterator this, geometry
+    iterator.call this, this, geometry, (intersection) ->
+      output.push intersection
+      false
+
+    if output.length > 0 then output else null
+
+  # Returns `true` if the bounds of the passed-in geometry intersects
+  # the current geometry bounds.
+  #
+  # geometry - The [Geometry]{agt.geom.Geometry} to test.
+  #
+  # Returns a {Boolean}.
+  boundsCollide: (geometry) ->
+    bounds1 = @bounds()
+    bounds2 = geometry.bounds()
+
+    not (
+      bounds1.top > bounds2.bottom or
+      bounds1.left > bounds2.right or
+      bounds1.bottom < bounds2.top or
+      bounds1.right < bounds2.left
+    )
+
+  ### Internal ###
+
+  intersectionsIterator: (geom1, geom2) ->
+    c1 = if geom1.classname then geom1.classname() else ''
+    c2 = if geom2.classname then geom2.classname() else ''
+    iterator = null
+    iterator = Intersections.iterators[c1 + c2]
+    iterator ||= Intersections.iterators[c1]
+    iterator ||= Intersections.iterators[c2]
+    iterator || @eachIntersections
+
+  eachIntersections: (geom1, geom2, block, providesDataInCallback=false) ->
+    points1 = geom1.points()
+    points2 = geom2.points()
+    length1 = points1.length
+    length2 = points2.length
+    lastIntersection = null
+
+    for i in [0..length1-2]
+      sv1 = points1[i]
+      ev1 = points1[i+1]
+      dif1x = ev1.x - sv1.x
+      dif1y = ev1.y - sv1.y
+      dif1l = dif1x * dif1x + dif1y * dif1y
+
+      for j in [0..length2-2]
+        sv2 = points2[j]
+        ev2 = points2[j+1]
+        dif2x = ev2.x - sv2.x
+        dif2y = ev2.y - sv2.y
+        dif2l = dif2x * dif2x + dif2y * dif2y
+
+        cross = @perCrossing sv1, {x:dif1x,y:dif1y}, sv2, {x:dif2x,y:dif2y}
+        d1x = cross.x - ev1.x
+        d1y = cross.y - ev1.y
+        d2x = cross.x - sv1.x
+        d2y = cross.y - sv1.y
+        d3x = cross.x - ev2.x
+        d3y = cross.y - ev2.y
+        d4x = cross.x - sv2.x
+        d4y = cross.y - sv2.y
+
+        d1l = d1x * d1x + d1y * d1y
+        d2l = d2x * d2x + d2y * d2y
+        d3l = d3x * d3x + d3y * d3y
+        d4l = d4x * d4x + d4y * d4y
+
+        if d1l <= dif1l and
+           d2l <= dif1l and
+           d3l <= dif2l and
+           d4l <= dif2l
+
+          if cross.equals lastIntersection
+            lastIntersection = cross
+            continue
+
+          if providesDataInCallback
+            context =
+              segment1: new agt.geom.Point dif1x, dif1y
+              segmentIndex1: i
+              segmentStart1: sv1
+              segmentEnd1: ev1
+              segment2: new agt.geom.Point dif2x, dif2y
+              segmentIndex2: j
+              segmentStart2: sv2
+              segmentEnd2: ev2
+
+          return if block.call this, cross, context
+          lastIntersection = cross
+
+  perCrossing: (start1, dir1, start2, dir2) ->
+    v3bx = start2.x - start1.x
+    v3by = start2.y - start1.y
+    perP1 = v3bx*dir2.y - v3by*dir2.x
+    perP2 = dir1.x*dir2.y - dir1.y*dir2.x
+
+    t = perP1 / perP2
+
+    cx = start1.x + dir1.x*t
+    cy = start1.y + dir1.y*t
+
+    new agt.geom.Point cx, cy