jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geom/Polygon.js

@@ -0,0 +1,263 @@
+/* Copyright (c) 2011 by The Authors.
+ * Published under the LGPL 2.1 license.
+ * See /license-notice.txt for the full text of the license notice.
+ * See /license.txt for the full text of the license.
+ */
+
+(function() {
+
+  /**
+   * Represents a linear polygon, which may include holes. The shell and holes
+   * of the polygon are represented by {@link LinearRing}s. In a valid polygon,
+   * holes may touch the shell or other holes at a single point. However, no
+   * sequence of touching holes may split the polygon into two pieces. The
+   * orientation of the rings in the polygon does not matter.
+   *
+   * The shell and holes must conform to the assertions specified in the <A
+   * HREF="http://www.opengis.org/techno/specs.htm">OpenGIS Simple Features
+   * Specification for SQL</A>.
+   */
+
+
+  /**
+   * @requires jsts/geom/Geometry.js
+   */
+
+  /**
+   * @extends {jsts.geom.Geometry}
+   * @constructor
+   */
+  jsts.geom.Polygon = function(shell, holes, factory) {
+    this.shell = shell || factory.createLinearRing(null);
+    this.holes = holes || [];
+    this.factory = factory;
+  };
+
+  jsts.geom.Polygon.prototype = new jsts.geom.Geometry();
+  jsts.geom.Polygon.constructor = jsts.geom.Polygon;
+
+  jsts.geom.Polygon.prototype.getCoordinate = function() {
+    return this.shell.getCoordinate();
+  };
+
+  jsts.geom.Polygon.prototype.getCoordinates = function() {
+    if (this.isEmpty()) {
+      return [];
+    }
+    var coordinates = [];
+    var k = -1;
+    var shellCoordinates = this.shell.getCoordinates();
+    for (var x = 0; x < shellCoordinates.length; x++) {
+      k++;
+      coordinates[k] = shellCoordinates[x];
+    }
+    for (var i = 0; i < this.holes.length; i++) {
+      var childCoordinates = this.holes[i].getCoordinates();
+      for (var j = 0; j < childCoordinates.length; j++) {
+        k++;
+        coordinates[k] = childCoordinates[j];
+      }
+    }
+    return coordinates;
+  };
+
+  /**
+   * @return {boolean}
+   */
+  jsts.geom.Polygon.prototype.isEmpty = function() {
+    return this.shell.isEmpty();
+  };
+
+  jsts.geom.Polygon.prototype.getExteriorRing = function() {
+    return this.shell;
+  };
+
+  jsts.geom.Polygon.prototype.getInteriorRingN = function(n) {
+    return this.holes[n];
+  };
+
+  jsts.geom.Polygon.prototype.getNumInteriorRing = function() {
+    return this.holes.length;
+  };
+
+  /**
+   * Returns the area of this <code>Polygon</code>
+   *
+   * @return the area of the polygon.
+   */
+  jsts.geom.Polygon.prototype.getArea = function() {
+    var area = 0.0;
+    area += Math.abs(jsts.algorithm.CGAlgorithms.signedArea(this.shell
+        .getCoordinateSequence()));
+    for (var i = 0; i < this.holes.length; i++) {
+      area -= Math.abs(jsts.algorithm.CGAlgorithms.signedArea(this.holes[i]
+          .getCoordinateSequence()));
+    }
+    return area;
+  };
+
+  /**
+   * Returns the perimeter of this <code>Polygon</code>
+   *
+   * @return the perimeter of the polygon.
+   */
+  jsts.geom.Polygon.prototype.getLength = function() {
+    var len = 0.0;
+    len += this.shell.getLength();
+    for (var i = 0; i < this.holes.length; i++) {
+      len += this.holes[i].getLength();
+    }
+    return len;
+  };
+
+  /**
+   * Computes the boundary of this geometry
+   *
+   * @return {Geometry} a lineal geometry (which may be empty).
+   * @see Geometry#getBoundary
+   */
+  jsts.geom.Polygon.prototype.getBoundary = function() {
+    if (this.isEmpty()) {
+      return this.getFactory().createMultiLineString(null);
+    }
+    var rings = [];
+    rings[0] = this.shell.clone();
+    for (var i = 0, len = this.holes.length; i < len; i++) {
+      rings[i + 1] = this.holes[i].clone();
+    }
+    // create LineString or MultiLineString as appropriate
+    if (rings.length <= 1)
+      return rings[0];
+    return this.getFactory().createMultiLineString(rings);
+  };
+
+  jsts.geom.Polygon.prototype.computeEnvelopeInternal = function() {
+    return this.shell.getEnvelopeInternal();
+  };
+
+  jsts.geom.Polygon.prototype.getDimension = function() {
+    return 2;
+  };
+
+  jsts.geom.Polygon.prototype.getBoundaryDimension = function() {
+    return 1;
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other
+   * @param {number}
+   *          tolerance
+   * @return {boolean}
+   */
+  jsts.geom.Polygon.prototype.equalsExact = function(other, tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+    if (this.isEmpty() && other.isEmpty()) {
+      return true;
+    }
+    if (this.isEmpty() !== other.isEmpty()) {
+      return false;
+    }
+
+    if (!this.shell.equalsExact(other.shell, tolerance)) {
+      return false;
+    }
+    if (this.holes.length !== other.holes.length) {
+      return false;
+    }
+    if (this.holes.length !== other.holes.length) {
+      return false;
+    }
+    for (var i = 0; i < this.holes.length; i++) {
+      if (!(this.holes[i]).equalsExact(other.holes[i], tolerance)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  jsts.geom.Polygon.prototype.compareToSameClass = function(o) {
+    return this.shell.compareToSameClass(o.shell);
+  };
+
+  jsts.geom.Polygon.prototype.apply = function(filter) {
+    if (filter instanceof jsts.geom.GeometryComponentFilter) {
+      filter.filter(this);
+      this.shell.apply(filter);
+      for (var i = 0, len = this.holes.length; i < len; i++) {
+        this.holes[i].apply(filter);
+      }
+    } else if (filter instanceof jsts.geom.GeometryFilter) {
+      filter.filter(this);
+    } else if (filter instanceof jsts.geom.CoordinateFilter) {
+      this.shell.apply(filter);
+      for (var i = 0, len = this.holes.length; i < len; i++) {
+        this.holes[i].apply(filter);
+      }
+    } else if (filter instanceof jsts.geom.CoordinateSequenceFilter) {
+      this.apply2.apply(this, arguments);
+    }
+  };
+
+  jsts.geom.Polygon.prototype.apply2 = function(filter) {
+    this.shell.apply(filter);
+    if (!filter.isDone()) {
+      for (var i = 0; i < this.holes.length; i++) {
+        this.holes[i].apply(filter);
+        if (filter.isDone())
+          break;
+      }
+    }
+    if (filter.isGeometryChanged()) {
+      // TODO: call this.geometryChanged(); when ported
+    }
+  };
+
+  /**
+   * Creates and returns a full copy of this {@link Polygon} object. (including
+   * all coordinates contained by it).
+   *
+   * @return a clone of this instance.
+   */
+  jsts.geom.Polygon.prototype.clone = function() {
+    var holes = [];
+
+    for (var i = 0, len = this.holes.length; i < len; i++) {
+      holes.push(this.holes[i].clone());
+    }
+
+    return this.factory.createPolygon(this.shell.clone(), holes);
+  };
+
+  jsts.geom.Polygon.prototype.normalize = function() {
+    this.normalize2(this.shell, true);
+    for (var i = 0, len = this.holes.length; i < len; i++) {
+      this.normalize2(this.holes[i], false);
+    }
+    // TODO: might need to supply comparison function
+    this.holes.sort();
+  };
+
+  /**
+   * @private
+   */
+  jsts.geom.Polygon.prototype.normalize2 = function(ring, clockwise) {
+    if (ring.isEmpty()) {
+      return;
+    }
+    var uniqueCoordinates = ring.points.slice(0, ring.points.length - 1);
+    var minCoordinate = jsts.geom.CoordinateArrays.minCoordinate(ring.points);
+    jsts.geom.CoordinateArrays.scroll(uniqueCoordinates, minCoordinate);
+    ring.points = uniqueCoordinates.concat();
+    ring.points[uniqueCoordinates.length] = uniqueCoordinates[0];
+    if (jsts.algorithm.CGAlgorithms.isCCW(ring.points) === clockwise) {
+      ring.points.reverse();
+    }
+  };
+
+  jsts.geom.Polygon.prototype.CLASS_NAME = 'jsts.geom.Polygon';
+
+})();

data/vendor/assets/javascripts/jsts/geom/PrecisionModel.js

@@ -0,0 +1,187 @@
+/* Copyright (c) 2011 by The Authors.
+ * Published under the LGPL 2.1 license.
+ * See /license-notice.txt for the full text of the license notice.
+ * See /license.txt for the full text of the license.
+ */
+
+
+
+/**
+ * Specifies the precision model of the {@link Coordinate}s in a
+ * {@link Geometry}. In other words, specifies the grid of allowable points for
+ * all <code>Geometry</code>s.
+ * <p>
+ * The {@link makePrecise} method allows rounding a coordinate to a "precise"
+ * value; that is, one whose precision is known exactly.
+ * <p>
+ * Coordinates are assumed to be precise in geometries. That is, the coordinates
+ * are assumed to be rounded to the precision model given for the geometry. JTS
+ * input routines automatically round coordinates to the precision model before
+ * creating Geometries. All internal operations assume that coordinates are
+ * rounded to the precision model. Constructive methods (such as boolean
+ * operations) always round computed coordinates to the appropriate precision
+ * model.
+ * <p>
+ * Currently one type of precision model are supported:
+ * <ul>
+ * <li>FLOATING - represents full double precision floating point.
+ * <p>
+ * Coordinates are represented internally as Java double-precision values. Since
+ * Java uses the IEEE-754 floating point standard, this provides 53 bits of
+ * precision.
+ * <p>
+ * JSTS methods currently do not handle inputs with different precision models.
+ *
+ * @constructor
+ */
+jsts.geom.PrecisionModel = function(modelType) {
+  if (typeof modelType === 'number') {
+    this.modelType = jsts.geom.PrecisionModel.FIXED;
+    this.scale = modelType;
+    return;
+  }
+
+  this.modelType = modelType || jsts.geom.PrecisionModel.FLOATING;
+
+  if (this.modelType === jsts.geom.PrecisionModel.FIXED) {
+    this.scale = 1.0;
+  }
+};
+
+
+/**
+ * @type {string}
+ */
+jsts.geom.PrecisionModel.FLOATING = 'FLOATING';
+
+
+/**
+ * @type {string}
+ */
+jsts.geom.PrecisionModel.FIXED = 'FIXED';
+
+
+/**
+ * @type {string}
+ */
+jsts.geom.PrecisionModel.FLOATING_SINGLE = 'FLOATING_SINGLE';
+
+jsts.geom.PrecisionModel.prototype.scale = null;
+jsts.geom.PrecisionModel.prototype.modelType = null;
+
+
+/**
+ * Tests whether the precision model supports floating point
+ *
+ * @return {boolean} if the precision model supports floating point.
+ */
+jsts.geom.PrecisionModel.prototype.isFloating = function() {
+  return this.modelType === jsts.geom.PrecisionModel.FLOATING ||
+      this.modelType === jsts.geom.PrecisionModel.FLOATING_SINLGE;
+};
+
+/**
+ * Returns the scale factor used to specify a fixed precision model. The number
+ * of decimal places of precision is equal to the base-10 logarithm of the scale
+ * factor. Non-integral and negative scale factors are supported. Negative scale
+ * factors indicate that the places of precision is to the left of the decimal
+ * point.
+ *
+ * @return the scale factor for the fixed precision model.
+ */
+jsts.geom.PrecisionModel.prototype.getScale = function() {
+  return this.scale;
+};
+
+/**
+ * @return {string} always jsts.geom.PrecisionModel.FLOATING.
+ */
+jsts.geom.PrecisionModel.prototype.getType = function() {
+  return this.modelType;
+};
+
+jsts.geom.PrecisionModel.prototype.equals = function(other) {
+  return true;
+
+  if (!(other instanceof jsts.geom.PrecisionModel)) {
+    return false;
+  }
+  var otherPrecisionModel = other;
+  return this.modelType === otherPrecisionModel.modelType &&
+      this.scale === otherPrecisionModel.scale;
+};
+
+
+/**
+ * Rounds a numeric value to the PrecisionModel grid. Asymmetric Arithmetic
+ * Rounding is used, to provide uniform rounding behaviour no matter where the
+ * number is on the number line.
+ * <p>
+ * This method has no effect on NaN values.
+ * <p>
+ * <b>Note:</b> Java's <code>Math#rint</code> uses the "Banker's Rounding"
+ * algorithm, which is not suitable for precision operations elsewhere in JTS.
+ */
+jsts.geom.PrecisionModel.prototype.makePrecise = function(val) {
+  if (val instanceof jsts.geom.Coordinate) {
+    this.makePrecise2(val);
+    return;
+  }
+
+  // don't change NaN values
+  if (isNaN(val))
+    return val;
+
+  // TODO: support single precision?
+  /*if (this.modelType == FLOATING_SINGLE) {
+    float floatSingleVal = (float) val;
+    return (double) floatSingleVal;
+  }*/
+  if (this.modelType === jsts.geom.PrecisionModel.FIXED) {
+    return Math.round(val * this.scale) / this.scale;
+  }
+  // modelType == FLOATING - no rounding necessary
+  return val;
+};
+
+
+/**
+ * Rounds a Coordinate to the PrecisionModel grid.
+ */
+jsts.geom.PrecisionModel.prototype.makePrecise2 = function(coord) {
+  // optimization for full precision
+  if (this.modelType === jsts.geom.PrecisionModel.FLOATING)
+    return;
+
+  coord.x = this.makePrecise(coord.x);
+  coord.y = this.makePrecise(coord.y);
+  // MD says it's OK that we're not makePrecise'ing the z [Jon Aquino]
+};
+
+
+/**
+ * Compares this {@link PrecisionModel} object with the specified object for
+ * order. A PrecisionModel is greater than another if it provides greater
+ * precision. The comparison is based on the value returned by the
+ * {@link #getMaximumSignificantDigits} method. This comparison is not strictly
+ * accurate when comparing floating precision models to fixed models; however,
+ * it is correct when both models are either floating or fixed.
+ *
+ * @param o
+ *          the <code>PrecisionModel</code> with which this
+ *          <code>PrecisionModel</code> is being compared.
+ * @return a negative integer, zero, or a positive integer as this
+ *         <code>PrecisionModel</code> is less than, equal to, or greater than
+ *         the specified <code>PrecisionModel.</code>
+ */
+jsts.geom.PrecisionModel.prototype.compareTo = function(o) {
+  var other = o;
+
+  // TODO: needs to be ported for fixed precision
+
+  // var sigDigits = this.getMaximumSignificantDigits();
+  // var otherSigDigits = other.getMaximumSignificantDigits();
+  // return (new Integer(sigDigits)).compareTo(new Integer(otherSigDigits));
+
+  return 0;
+};

data/vendor/assets/javascripts/jsts/geom/Triangle.js

@@ -0,0 +1,313 @@
+/* Copyright (c) 2011 by The Authors.
+ * Published under the LGPL 2.1 license.
+ * See /license-notice.txt for the full text of the license notice.
+ * See /license.txt for the full text of the license.
+*/
+
+
+
+/**
+ * Represents a planar triangle, and provides methods for calculating various
+ * properties of triangles.
+ *
+ * @constructor
+ * @param {jsts.geom.Coordinate}
+ *          p0 a coordinate.
+ * @param {jsts.geom.Coordinate}
+ *          p1 a coordinate.
+ * @param {jsts.geom.Coordinate}
+ *          p2 a coordinate.
+ */
+jsts.geom.Triangle = function(p0, p1, p2) {
+  this.p0 = p0;
+  this.p1 = p1;
+  this.p2 = p2;
+};
+
+/**
+ * Tests whether a triangle is acute. A triangle is acute iff all interior
+ * angles are acute. This is a strict test - right triangles will return
+ * <tt>false</tt> A triangle which is not acute is either right or obtuse.
+ * <p>
+ * Note: this implementation is not robust for angles very close to 90 degrees.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertex of the triangle.
+ * @return {Boolean} true if the triangle is acute.
+ */
+jsts.geom.Triangle.isAcute = function(a, b, c) {
+  if (!jsts.algorithm.Angle.isAcute(a, b, c)) {
+    return false;
+  }
+  if (!jsts.algorithm.Angle.isAcute(b, c, a)) {
+    return false;
+  }
+  if (!jsts.algorithm.Angle.isAcute(c, a, b)) {
+    return false;
+  }
+  return true;
+};
+
+
+/**
+ * Computes the line which is the perpendicular bisector of the line segment
+ * a-b.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a point.
+ * @param {jsts.geom.Coordinate}
+ *          b another point.
+ * @return {jsts.algorithm.HCoordinate} the perpendicular bisector, as an
+ *         HCoordinate.
+ */
+jsts.geom.Triangle.perpendicularBisector = function(a, b) {
+  // returns the perpendicular bisector of the line segment ab
+  var dx, dy, l1, l2;
+
+  dx = b.x - a.x;
+  dy = b.y - a.y;
+
+  l1 = new jsts.algorithm.HCoordinate(a.x + dx / 2.0, a.y + dy / 2.0, 1.0);
+  l2 = new jsts.algorithm.HCoordinate(a.x - dy + dx / 2.0, a.y + dx + dy / 2.0,
+      1.0);
+  return new jsts.algorithm.HCoordinate(l1, l2);
+};
+
+
+/**
+ * Computes the circumcentre of a triangle. The circumcentre is the centre of
+ * the circumcircle, the smallest circle which encloses the triangle. It is also
+ * the common intersection point of the perpendicular bisectors of the sides of
+ * the triangle, and is the only point which has equal distance to all three
+ * vertices of the triangle.
+ * <p>
+ * This method uses an algorithm due to J.R.Shewchuk which uses normalization to
+ * the origin to improve the accuracy of computation. (See <i>Lecture Notes on
+ * Geometric Robustness</i>, Jonathan Richard Shewchuk, 1999).
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertx of the triangle.
+ * @return {jsts.geom.Coordinate} the circumcentre of the triangle.
+ */
+jsts.geom.Triangle.circumcentre = function(a, b, c) {
+  var cx, cy, ax, ay, bx, by, denom, numx, numy, ccx, ccy;
+
+  cx = c.x;
+  cy = c.y;
+  ax = a.x - cx;
+  ay = a.y - cy;
+  bx = b.x - cx;
+  by = b.y - cy;
+
+  denom = 2 * jsts.geom.Triangle.det(ax, ay, bx, by);
+  numx = jsts.geom.Triangle.det(ay, ax * ax + ay * ay, by, bx * bx + by * by);
+  numy = jsts.geom.Triangle.det(ax, ax * ax + ay * ay, bx, bx * bx + by * by);
+
+  ccx = cx - numx / denom;
+  ccy = cy + numy / denom;
+
+  return new jsts.geom.Coordinate(ccx, ccy);
+};
+
+
+/**
+ * Computes the determinant of a 2x2 matrix. Uses standard double-precision
+ * arithmetic, so is susceptible to round-off error.
+ *
+ * @param {Number}
+ *          m00 the [0,0] entry of the matrix.
+ * @param {Number}
+ *          m01 the [0,1] entry of the matrix.
+ * @param {Number}
+ *          m10 the [1,0] entry of the matrix.
+ * @param {Number}
+ *          m11 the [1,1] entry of the matrix.
+ * @return {Number} the determinant.
+ */
+jsts.geom.Triangle.det = function(m00, m01, m10, m11) {
+  return m00 * m11 - m01 * m10;
+};
+
+
+/**
+ * Computes the incentre of a triangle. The <i>inCentre</i> of a triangle is
+ * the point which is equidistant from the sides of the triangle. It is also the
+ * point at which the bisectors of the triangle's angles meet. It is the centre
+ * of the triangle's <i>incircle</i>, which is the unique circle that is
+ * tangent to each of the triangle's three sides.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertx of the triangle.
+ * @return {jsts.geom.Coordinate} the point which is the incentre of the
+ *         triangle.
+ */
+jsts.geom.Triangle.inCentre = function(a, b, c) {
+  var len0, len1, len2, circum, inCentreX, inCentreY;
+
+  // the lengths of the sides, labelled by their opposite vertex
+  len0 = b.distance(c);
+  len1 = a.distance(c);
+  len2 = a.distance(b);
+  circum = len0 + len1 + len2;
+
+  inCentreX = (len0 * a.x + len1 * b.x + len2 * c.x) / circum;
+  inCentreY = (len0 * a.y + len1 * b.y + len2 * c.y) / circum;
+
+  return new jsts.geom.Coordinate(inCentreX, inCentreY);
+};
+
+
+/**
+ * Computes the centroid (centre of mass) of a triangle. This is also the point
+ * at which the triangle's three medians intersect (a triangle median is the
+ * segment from a vertex of the triangle to the midpoint of the opposite side).
+ * The centroid divides each median in a ratio of 2:1. The centroid always lies
+ * within the triangle.
+ *
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertx of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertx of the triangle.
+ * @return {jsts.geom.Coordinate} the centroid of the triangle.
+ */
+jsts.geom.Triangle.centroid = function(a, b, c) {
+  var x, y;
+
+  x = (a.x + b.x + c.x) / 3;
+  y = (a.y + b.y + c.y) / 3;
+
+  return new jsts.geom.Coordinate(x, y);
+};
+
+
+/**
+ * Computes the length of the longest side of a triangle
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertex of the triangle.
+ * @return {Number} the length of the longest side of the triangle.
+ */
+jsts.geom.Triangle.longestSideLength = function(a, b, c) {
+  var lenAB, lenBC, lenCA, maxLen;
+
+  lenAB = a.distance(b);
+  lenBC = b.distance(c);
+  lenCA = c.distance(a);
+  maxLen = lenAB;
+
+  if (lenBC > maxLen) {
+    maxLen = lenBC;
+  }
+  if (lenCA > maxLen) {
+    maxLen = lenCA;
+  }
+  return maxLen;
+};
+
+
+/**
+ * Computes the point at which the bisector of the angle ABC cuts the segment
+ * AC.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertex of the triangle.
+ * @return {jsts.geom.Coordinate} the angle bisector cut point.
+ */
+jsts.geom.Triangle.angleBisector = function(a, b, c) {
+  /**
+   * Uses the fact that the lengths of the parts of the split segment are
+   * proportional to the lengths of the adjacent triangle sides
+   */
+  var len0, len2, frac, dx, dy, splitPt;
+
+  len0 = b.distance(a);
+  len2 = b.distance(c);
+  frac = len0 / (len0 + len2);
+  dx = c.x - a.x;
+  dy = c.y - a.y;
+
+  splitPt = new jsts.geom.Coordinate(a.x + frac * dx, a.y + frac * dy);
+  return splitPt;
+};
+
+
+/**
+ * Computes the 2D area of a triangle. The area value is always non-negative.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertex of the triangle.
+ * @return {Number} the area of the triangle.
+ */
+jsts.geom.Triangle.area = function(a, b, c) {
+  return Math
+      .abs(((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2.0);
+};
+
+
+/**
+ * Computes the signed 2D area of a triangle. The area value is positive if the
+ * triangle is oriented CW, and negative if it is oriented CCW.
+ * <p>
+ * The signed area value can be used to determine point orientation, but the
+ * implementation in this method is susceptible to round-off errors. Use
+ * {@link CGAlgorithms#orientationIndex(Coordinate, Coordinate, Coordinate)} for
+ * robust orientation calculation.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          a a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          b a vertex of the triangle.
+ * @param {jsts.geom.Coordinate}
+ *          c a vertex of the triangle.
+ * @return {Number} the signed 2D area of the triangle.
+ *
+ */
+jsts.geom.Triangle.signedArea = function(a, b, c) {
+  /**
+   * Uses the formula 1/2 * | u x v | where u,v are the side vectors of the
+   * triangle x is the vector cross-product For 2D vectors, this formula
+   * simplifies to the expression below
+   */
+  return ((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2.0;
+};
+
+/**
+ * Computes the incentre of a triangle. The <i>incentre</i> of a triangle is
+ * the point which is equidistant from the sides of the triangle. It is also the
+ * point at which the bisectors of the triangle's angles meet. It is the centre
+ * of the triangle's <i>incircle</i>, which is the unique circle that is
+ * tangent to each of the triangle's three sides.
+ *
+ * @return {jsts.geom.Coordinate} the point which is the inCentre of the
+ *         triangle.
+ */
+jsts.geom.Triangle.prototype.inCentre = function() {
+  return jsts.geom.Triangle.inCentre(this.p0, this.p1, this.p2);
+};