Takes a collection of detailed polygons and smooths out the edges to a given tolerance. It will probably use a Ramer Douglas Peucker algorithm or something similar. This will probably require the use of topojson to maintain edge integrity of geographies.

g.simplify(polys, 2000, function(err, smoothed){
  console.log(smoothed)
})

takes a linestring and curves it.

encodes geojson as topology using topojson.

Tin needs to have the z val encoded into the triangles.

Takes a line and bisects it, returning the midpoint.

Beizer curve based smoothing for polygons and linestrings. I plan to use topojson as an intermediate format in conjunction with mapshaper's repair functionality to maintain topological integrity.

Takes a set of points and creates contours from a property. The algorithm is something like the following:

1. create tin from points with g.tin
2. get the extent of the tin with g.extent
3. create a grid within the extent using g.grid
4. get the value at each point from the tin using g.tinpoint
5. calculate the contour break point quantiles using g.quantile
6. reclass the points using g.reclass
7. pass the grid with data to the conrec algorithm

g.contours(points, 'elevation', function(err, contourPolygons){
  console.log(contourPolygons)
})

Takes a feature or FeatureCollection and outputs all of the vertices as a collection of points.

Point clustering for rendering lots of points

Takes a set of points and estimates values on a grid.

This should take a set of polygons, a set of points, and a field name. It will then add a [fieldName]+'_sum' which will be equal to the sum of the field for all points within the polygon.

Classification based on equal intervals.

Jenks natural breaks classifier

Takes an featurecollection of polygons and outputs a unionized version, where overlapping polygons are merged.

g.union(polys, function(err, merged){
  // assuming polys contained two overlapping polys, a single polygon would be returned
  console.log(merged)
})

Takes a set of polygons, a set of points, and a field name, then outputs a polygon with a [fieldName]+'_avg' property appended that is the average of the points contained in the polygon.

Returns the area of a polygon in a specified unit.

g.area(poly, 'miles', function(err, area){
  console.log(area)
})

Removes features that have a property equal to the input.

var points = g.featurecollection([g.point(1,1, {type: 'oak'}), 
                                          g.point(1,2, {type: 'maple'}), 
                                          g.point(2,1, {type: 'cedar'})])
g.remove(points, 'type', 'maple', function(err, remainingPts){
  // the maple point has been removed
  console.log(remainingPts) 
})

tag should take a collection of points and polys instead of just one poly.

kriging contours

takes a bbox [xmin,ymin,xmax,ymax] and returns a rectangular polygon.

Tag a point with a property from the polygon. An example would be adding a zipcode column to a point based on which zip polygon it falls in.

g.tag(points, polys, 'zipcode', function(err){

})

This could be very handy and should just considered a suggestion.

g.clip(polys, clippolys, function(err, clipedpolys){
console.log(clipedpolys)
})

function that will switch the x, y of every coordinate in a feature or feature collection

Contouring only works on square data. Make this able to process any rectangular extent.

switch g.combine to take featurecollections

Gets the percentile breaks for N equal breaks. Specify the property and the number of quantiles.

g.quantile(points, 'elevation', 5, function(err, quantiles){
  console.log(quantiles)
  // [0, 359.983, 689.226, 1023.864, 3984.234, 5113.349]
})

Gets a polygon representing the intersection between two other polygons.

g.intersect(poly1, poly2, function(err, result){
  console.log(result)
})

Interpolate an arbitrary point's z value from a tin.

g.tinpoint(point, tin, function(err, val){
  console.log(val)
})

take a point collection and an integer and return a random sample of points

get the extents, then convert the bbox result to a polygon in a single step.

Demo site featuring inputs and outputs displayed on leaflet maps.

changes the size of a bbox by the factor of x

In the load example the arguments should be switched fron
t.load(geojsonFile, function(trees, err)
into

t.load(geojsonFile, function(err, trees)

In "distance" using degree: the degree is the same
on
t.distance(point1, point2, unit, function(err, distance)
and
t.distance(point2, point1, unit, function(err, distance)

is that correct?

The planepoint example does not work.

Save out a feature or collection to various output file types. This will start out with geojson, but I will probably add topojson, and shapefile as well. I do not want to make ogr2ogr a dependency here, so I will keep it pretty simple.

Returns a point that is the average of all points in a polygon.

g.centroid(point, poly, function(err, pt){
  console.log(pt)
})

Buffer should work with polygons and lines

Takes 2 polygons. The 1st polygon is returned, but with any overlaps removed.

g.erase(poly1, poly2, function(err, poly3){
  // poly3 is now poly1 minus any portion that overlapped with poly2
  console.log(poly3)
})

Standard deviation breaks

add an option for topojson save output.

I'm wondering whether it makes sense to abstract around geojson literal creation, and whether this library should talk in Features rather than Geometry objects - root-level geoms are legal in GeoJSON and similar geometrical libraries like Shapely don't attempt to deal with property data.

Change values that fall within a range to a discrete value.

var ranges = [[0, 50, 1], [50, 100, 2], [100, Infinity, 3]]
g.reclass(points, 'trees', ranges, function(err, reclassPts){
  console.log(reclassPts)
})

get the square extents of a feature or featurcollection of any type.

Support holes in contours.

Return true if point is inside of a polygon. This will probably use the even odd rule algorithm.

g.inside(point(10,5), polygon, function(err, poly){
  console.log(poly)
})

aggregate takes a set of polys, a set of points, and an aggregation field map, then automatically aggs all of the point fields over to the polygons.

A field map would look something like this:

[
{
in: 'population',
out: 'pop_avg',
aggregate: 'average'
}, ...
]

I have no idea if this is even possible, but I would like to be able to include some sort of styling info with the features. It is my understanding that each platform has its own way of styling and symbology, so this may not be possible. Research this issue and come to a conclusion one way or the other.

Filter out features based on a property

g.filter(polys, 'ZipCode', '29407', function(err, matchingPoly){
  console.log(matchingPoly)
})

featurecollection, planepoint, and a couple others need to be consistent with the rest of the api for casing.

Takes an array of features and sets up a basic featurecollection.

var fc = g.featurecollection([g.point(1,2), g.point(19, 23), g.point(11, 13), g.point(-3, -14)])
console.log(fc)