/**
* Converts a GeoJSON coordinates to the defined `projection`
*
* @private
* @param {GeoJSON} geojson GeoJSON Feature or Geometry
* @param {string} projection defines the projection system to convert the coordinates to
* @param {Object} [options] Optional parameters
* @param {boolean} [options.mutate=false] allows GeoJSON input to be mutated (significant performance increase if true)
* @returns {GeoJSON} true/false
*/
function convert(geojson, projection, options) {
// Optional parameters
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
var mutate = options.mutate;
// Validation
if (!geojson) throw new Error('geojson is required');
// Handle Position
if (Array.isArray(geojson) && isNumber(geojson[0])) geojson = (projection === 'mercator') ? convertToMercator(geojson) : convertToWgs84(geojson);
// Handle GeoJSON
else {
// Handle possible data mutation
if (mutate !== true) geojson = clone(geojson);
coordEach(geojson, function (coord) {
var newCoord = (projection === 'mercator') ? convertToMercator(coord) : convertToWgs84(coord);
coord[0] = newCoord[0];
coord[1] = newCoord[1];
});
}
return geojson;
}
export function randomPolygon(count, options) {
// Optional parameters
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
var bbox = options.bbox;
var num_vertices = options.num_vertices;
var max_radial_length = options.max_radial_length;
if (count === undefined || count === null) count = 1;
// Validation
if (!isNumber(num_vertices)) num_vertices = 10;
if (!isNumber(max_radial_length)) max_radial_length = 10;
var features = [];
for (var i = 0; i < count; i++) {
var vertices = [],
circle_offsets = Array.apply(null,
new Array(num_vertices + 1)).map(Math.random);
circle_offsets.forEach(sumOffsets);
circle_offsets.forEach(scaleOffsets);
vertices[vertices.length - 1] = vertices[0]; // close the ring
// center the polygon around something
vertices = vertices.map(vertexToCoordinate(randomPosition(bbox)));
features.push(polygon([vertices]));
}
function sumOffsets(cur, index, arr) {
arr[index] = (index > 0) ? cur + arr[index - 1] : cur;
}
function scaleOffsets(cur) {
cur = cur * 2 * Math.PI / circle_offsets[circle_offsets.length - 1];
var radial_scaler = Math.random();
vertices.push([
radial_scaler * max_radial_length * Math.sin(cur),
radial_scaler * max_radial_length * Math.cos(cur)
]);
}
return featureCollection(features);
}
export function randomLineString(count, options) {
// Optional parameters
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
var bbox = options.bbox;
var num_vertices = options.num_vertices;
var max_length = options.max_length;
var max_rotation = options.max_rotation;
if (count === undefined || count === null) count = 1;
// Default parameters
if (!isNumber(num_vertices) || num_vertices < 2) num_vertices = 10;
if (!isNumber(max_length)) max_length = 0.0001;
if (!isNumber(max_rotation)) max_rotation = Math.PI / 8;
var features = [];
for (var i = 0; i < count; i++) {
var startingPoint = randomPosition(bbox);
var vertices = [startingPoint];
for (var j = 0; j < num_vertices - 1; j++) {
var priorAngle = (j === 0) ?
Math.random() * 2 * Math.PI :
Math.tan(
(vertices[j][1] - vertices[j - 1][1]) /
(vertices[j][0] - vertices[j - 1][0])
);
var angle = priorAngle + (Math.random() - 0.5) * max_rotation * 2;
var distance = Math.random() * max_length;
vertices.push([
vertices[j][0] + distance * Math.cos(angle),
vertices[j][1] + distance * Math.sin(angle)
]);
}
features.push(lineString(vertices));
}
return featureCollection(features);
}
featureEach(centroids, function (theCentroid) {
var weightValue = theCentroid.properties.weight;
var weight = (weightValue === undefined || weightValue === null) ? 1 : weightValue;
weight = Number(weight);
if (!isNumber(weight)) throw new Error('weight value must be a number');
if (weight > 0) {
centroidCount += 1;
var distanceFromCandidate = weight * distance(theCentroid, candidateMedian);
if (distanceFromCandidate === 0) distanceFromCandidate = 1;
var k = weight / distanceFromCandidate;
candidateXsum += theCentroid.geometry.coordinates[0] * k;
candidateYsum += theCentroid.geometry.coordinates[1] * k;
kSum += k;
}
});
/**
* Takes a {@link FeatureCollection} of points and calculates the median center,
* algorithimically. The median center is understood as the point that is
* requires the least total travel from all other points.
*
* Turfjs has four different functions for calculating the center of a set of
* data. Each is useful depending on circumstance.
*
* `@turf/center` finds the simple center of a dataset, by finding the
* midpoint between the extents of the data. That is, it divides in half the
* farthest east and farthest west point as well as the farthest north and
* farthest south.
*
* `@turf/center-of-mass` imagines that the dataset is a sheet of paper.
* The center of mass is where the sheet would balance on a fingertip.
*
* `@turf/center-mean` takes the averages of all the coordinates and
* produces a value that respects that. Unlike `@turf/center`, it is
* sensitive to clusters and outliers. It lands in the statistical middle of a
* dataset, not the geographical. It can also be weighted, meaning certain
* points are more important than others.
*
* `@turf/center-median` takes the mean center and tries to find, iteratively,
* a new point that requires the least amount of travel from all the points in
* the dataset. It is not as sensitive to outliers as `@turf/center`, but it is
* attracted to clustered data. It, too, can be weighted.
*
* **Bibliography**
*
* Harold W. Kuhn and Robert E. Kuenne, “An Efficient Algorithm for the
* Numerical Solution of the Generalized Weber Problem in Spatial
* Economics,” _Journal of Regional Science_ 4, no. 2 (1962): 21–33,
* doi:{@link https://doi.org/10.1111/j.1467-9787.1962.tb00902.x}.
*
* James E. Burt, Gerald M. Barber, and David L. Rigby, _Elementary
* Statistics for Geographers_, 3rd ed., New York: The Guilford
* Press, 2009, 150–151.
*
* @name centerMedian
* @param {FeatureCollection<any>} features Any GeoJSON Feature Collection
* @param {Object} [options={}] Optional parameters
* @param {string} [options.weight] the property name used to weight the center
* @param {number} [options.tolerance=0.001] the difference in distance between candidate medians at which point the algorighim stops iterating.
* @param {number} [options.counter=10] how many attempts to find the median, should the tolerance be insufficient.
* @returns {Feature<Point>} The median center of the collection
* @example
* var points = turf.points([[0, 0], [1, 0], [0, 1], [5, 8]]);
* var medianCenter = turf.centerMedian(points);
*
* //addToMap
* var addToMap = [points, medianCenter]
*/
function centerMedian(features, options) {
// Optional params
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
var counter = options.counter || 10;
if (!isNumber(counter)) throw new Error('counter must be a number');
var weightTerm = options.weight;
// Calculate mean center:
var meanCenter = centerMean(features, {weight: options.weight});
// Calculate center of every feature:
var centroids = featureCollection([]);
featureEach(features, function (feature) {
centroids.features.push(centroid(feature, {weight: feature.properties[weightTerm]}));
});
centroids.properties = {
tolerance: options.tolerance,
medianCandidates: []
};
return findMedian(meanCenter.geometry.coordinates, [0, 0], centroids, counter);
}
/**
* Takes a bounding box and the diameter of the cell and returns a {@link FeatureCollection} of flat-topped
* hexagons or triangles ({@link Polygon} features) aligned in an "odd-q" vertical grid as
* described in [Hexagonal Grids](http://www.redblobgames.com/grids/hexagons/).
*
* @name hexGrid
* @param {BBox} bbox extent in [minX, minY, maxX, maxY] order
* @param {number} cellSide length of the side of the the hexagons or triangles, in units. It will also coincide with the
* radius of the circumcircle of the hexagons.
* @param {Object} [options={}] Optional parameters
* @param {string} [options.units='kilometers'] used in calculating cell size, can be degrees, radians, miles, or kilometers
* @param {Object} [options.properties={}] passed to each hexagon or triangle of the grid
* @param {Feature<Polygon|MultiPolygon>} [options.mask] if passed a Polygon or MultiPolygon, the grid Points will be created only inside it
* @param {boolean} [options.triangles=false] whether to return as triangles instead of hexagons
* @returns {FeatureCollection<Polygon>} a hexagonal grid
* @example
* var bbox = [-96,31,-84,40];
* var cellSide = 50;
* var options = {units: 'miles'};
*
* var hexgrid = turf.hexGrid(bbox, cellSide, options);
*
* //addToMap
* var addToMap = [hexgrid];
*/
function hexGrid(bbox, cellSide, options) {
// Optional parameters
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
// var units = options.units;
var properties = options.properties || {};
var triangles = options.triangles;
var mask = options.mask;
// validation
if (cellSide === null || cellSide === undefined) throw new Error('cellSide is required');
if (!isNumber(cellSide)) throw new Error('cellSide is invalid');
if (!bbox) throw new Error('bbox is required');
if (!Array.isArray(bbox)) throw new Error('bbox must be array');
if (bbox.length !== 4) throw new Error('bbox must contain 4 numbers');
if (mask && ['Polygon', 'MultiPolygon'].indexOf(getType(mask)) === -1) throw new Error('options.mask must be a (Multi)Polygon');
var west = bbox[0];
var south = bbox[1];
var east = bbox[2];
var north = bbox[3];
var centerY = (south + north) / 2;
var centerX = (west + east) / 2;
// https://github.com/Turfjs/turf/issues/758
var xFraction = cellSide * 2 / (distance([west, centerY], [east, centerY], options));
var cellWidth = xFraction * (east - west);
var yFraction = cellSide * 2 / (distance([centerX, south], [centerX, north], options));
var cellHeight = yFraction * (north - south);
var radius = cellWidth / 2;
var hex_width = radius * 2;
var hex_height = Math.sqrt(3) / 2 * cellHeight;
var box_width = east - west;
var box_height = north - south;
var x_interval = 3 / 4 * hex_width;
var y_interval = hex_height;
// adjust box_width so all hexagons will be inside the bbox
var x_span = (box_width - hex_width) / (hex_width - radius / 2);
var x_count = Math.floor(x_span);
var x_adjust = ((x_count * x_interval - radius / 2) - box_width) / 2 - radius / 2 + x_interval / 2;
// adjust box_height so all hexagons will be inside the bbox
var y_count = Math.floor((box_height - hex_height) / hex_height);
var y_adjust = (box_height - y_count * hex_height) / 2;
var hasOffsetY = y_count * hex_height - box_height > hex_height / 2;
if (hasOffsetY) {
y_adjust -= hex_height / 4;
}
// Precompute cosines and sines of angles used in hexagon creation for performance gain
var cosines = [];
var sines = [];
for (var i = 0; i < 6; i++) {
var angle = 2 * Math.PI / 6 * i;
cosines.push(Math.cos(angle));
sines.push(Math.sin(angle));
}
var results = [];
for (var x = 0; x <= x_count; x++) {
for (var y = 0; y <= y_count; y++) {
var isOdd = x % 2 === 1;
if (y === 0 && isOdd) continue;
if (y === 0 && hasOffsetY) continue;
var center_x = x * x_interval + west - x_adjust;
var center_y = y * y_interval + south + y_adjust;
if (isOdd) {
center_y -= hex_height / 2;
}
if (triangles === true) {
hexTriangles(
[center_x, center_y],
cellWidth / 2,
cellHeight / 2,
properties,
cosines,
sines).forEach(function (triangle) {
if (mask) {
if (intersect(mask, triangle)) results.push(triangle);
} else {
results.push(triangle);
}
});
} else {
var hex = hexagon(
[center_x, center_y],
cellWidth / 2,
cellHeight / 2,
properties,
cosines,
sines
);
if (mask) {
if (intersect(mask, hex)) results.push(hex);
} else {
results.push(hex);
}
}
}
}
return featureCollection(results);
}
/**
* Takes a bounding box and a cell depth and returns a set of triangular {@link Polygon|polygons} in a grid.
*
* @name triangleGrid
* @param {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
* @param {number} cellSide dimension of each cell
* @param {Object} [options={}] Optional parameters
* @param {string} [options.units='kilometers'] used in calculating cellSide, can be degrees, radians, miles, or kilometers
* @param {Feature<Polygon|MultiPolygon>} [options.mask] if passed a Polygon or MultiPolygon, the grid Points will be created only inside it
* @param {Object} [options.properties={}] passed to each point of the grid
* @returns {FeatureCollection<Polygon>} grid of polygons
* @example
* var bbox = [-95, 30 ,-85, 40];
* var cellSide = 50;
* var options = {units: 'miles'};
*
* var triangleGrid = turf.triangleGrid(bbox, cellSide, options);
*
* //addToMap
* var addToMap = [triangleGrid];
*/
function triangleGrid(bbox, cellSide, options) {
// Optional parameters
options = options || {};
if (!isObject(options)) throw new Error('options is invalid');
// var units = options.units;
var properties = options.properties;
var mask = options.mask;
// Containers
var results = [];
// Input Validation
if (cellSide === null || cellSide === undefined) throw new Error('cellSide is required');
if (!isNumber(cellSide)) throw new Error('cellSide is invalid');
if (!bbox) throw new Error('bbox is required');
if (!Array.isArray(bbox)) throw new Error('bbox must be array');
if (bbox.length !== 4) throw new Error('bbox must contain 4 numbers');
if (mask && ['Polygon', 'MultiPolygon'].indexOf(getType(mask)) === -1) throw new Error('options.mask must be a (Multi)Polygon');
// Main
var xFraction = cellSide / (distance([bbox[0], bbox[1]], [bbox[2], bbox[1]], options));
var cellWidth = xFraction * (bbox[2] - bbox[0]);
var yFraction = cellSide / (distance([bbox[0], bbox[1]], [bbox[0], bbox[3]], options));
var cellHeight = yFraction * (bbox[3] - bbox[1]);
var xi = 0;
var currentX = bbox[0];
while (currentX <= bbox[2]) {
var yi = 0;
var currentY = bbox[1];
while (currentY <= bbox[3]) {
var cellTriangle1 = null;
var cellTriangle2 = null;
if (xi % 2 === 0 && yi % 2 === 0) {
cellTriangle1 = polygon([[
[currentX, currentY],
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY]
]], properties);
cellTriangle2 = polygon([[
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY + cellHeight]
]], properties);
} else if (xi % 2 === 0 && yi % 2 === 1) {
cellTriangle1 = polygon([[
[currentX, currentY],
[currentX + cellWidth, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY]
]], properties);
cellTriangle2 = polygon([[
[currentX, currentY],
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY + cellHeight],
[currentX, currentY]
]], properties);
} else if (yi % 2 === 0 && xi % 2 === 1) {
cellTriangle1 = polygon([[
[currentX, currentY],
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY + cellHeight],
[currentX, currentY]
]], properties);
cellTriangle2 = polygon([[
[currentX, currentY],
[currentX + cellWidth, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY]
]], properties);
} else if (yi % 2 === 1 && xi % 2 === 1) {
cellTriangle1 = polygon([[
[currentX, currentY],
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY]
]], properties);
cellTriangle2 = polygon([[
[currentX, currentY + cellHeight],
[currentX + cellWidth, currentY + cellHeight],
[currentX + cellWidth, currentY],
[currentX, currentY + cellHeight]
]], properties);
}
if (mask) {
if (intersect(mask, cellTriangle1)) results.push(cellTriangle1);
if (intersect(mask, cellTriangle2)) results.push(cellTriangle2);
} else {
results.push(cellTriangle1);
results.push(cellTriangle2);
}
currentY += cellHeight;
yi++;
}
xi++;
currentX += cellWidth;
}
return featureCollection(results);
}