/**
* Define Transverse Mercator projection
*
* @private
* @param {Geometry|Feature<any>} geojson Base projection on center of GeoJSON
* @returns {GeoProjection} D3 Geo Transverse Mercator Projection
*/
function defineProjection(geojson) {
var coords = center(geojson).geometry.coordinates.reverse();
var rotate = coords.map(function (coord) { return -coord; });
return geoTransverseMercator()
.center(coords)
.rotate(rotate)
.scale(earthRadius);
}
var insideFeatures = _.filter(data.features, function (feature) {
if (!feature.geometry) {
return false;
}
if (feature.geometry.type !== 'Point') {
return booleanContains(filter, center(feature));
}
return booleanContains(filter, feature);
});
/**
* Define Transverse Mercator projection
*
* @private
* @param {Geometry|Feature<any>} geojson Base projection on center of GeoJSON
* @returns {GeoProjection} D3 Geo Transverse Mercator Projection
*/
function defineProjection(geojson) {
var coords = center(geojson).geometry.coordinates.reverse();
var rotate = coords.map(function (coord) { return -coord; });
var projection = d3.geoTransverseMercator()
.center(coords)
.rotate(rotate)
.scale(6373000);
return projection;
}
this.map.on('click', (event) => {
const features = this.map
.queryRenderedFeatures(event.point, { layers: [taskPolygons] });
if (!features.length) {
return;
}
const feature = features[0];
const popoverContent = ReactDOMServer.renderToStaticMarkup(
<MapTaskPopover data={feature.properties} />
);
new mapboxgl.Popup()
.setLngLat(center(feature).geometry.coordinates)
.setHTML(popoverContent)
.addTo(this.map);
});
/**
* Define Origin
*
* @private
* @param {GeoJSON} geojson GeoJSON
* @param {string|Geometry|Feature<Point>|Array<number>} origin sw/se/nw/ne/center/centroid
* @returns {Feature<Point>} Point origin
*/
function defineOrigin(geojson, origin) {
// Default params
if (origin === undefined || origin === null) origin = 'centroid';
// Input Geometry|Feature<Point>|Array<number>
if (Array.isArray(origin) || typeof origin === 'object') return getCoord(origin);
// Define BBox
var bbox = (geojson.bbox) ? geojson.bbox : turfBBox(geojson);
var west = bbox[0];
var south = bbox[1];
var east = bbox[2];
var north = bbox[3];
switch (origin) {
case 'sw':
case 'southwest':
case 'westsouth':
case 'bottomleft':
return point([west, south]);
case 'se':
case 'southeast':
case 'eastsouth':
case 'bottomright':
return point([east, south]);
case 'nw':
case 'northwest':
case 'westnorth':
case 'topleft':
return point([west, north]);
case 'ne':
case 'northeast':
case 'eastnorth':
case 'topright':
return point([east, north]);
case 'center':
return center(geojson);
case undefined:
case null:
case 'centroid':
return centroid(geojson);
default:
throw new Error('invalid origin');
}
}
// define origin, as defined in transform-scale, and style it
function markedOrigin(geojson, origin, properties = {'marker-color': '#00F', 'marker-symbol': 'circle'}) {
// Input Geometry|Feature<Point>|Array<number>
if (Array.isArray(origin) || typeof origin === 'object') return point(getCoord(origin), properties);
// Define BBox
const [west, south, east, north] = (geojson.bbox) ? geojson.bbox : turfBBox(geojson);
switch (origin) {
case 'sw':
case 'southwest':
case 'westsouth':
case 'bottomleft':
return point([west, south], properties);
case 'se':
case 'southeast':
case 'eastsouth':
case 'bottomright':
return point([east, south], properties);
case 'nw':
case 'northwest':
case 'westnorth':
case 'topleft':
return point([west, north], properties);
case 'ne':
case 'northeast':
case 'eastnorth':
case 'topright':
return point([east, north], properties);
case 'center':
var cr = center(geojson);
cr.properties = properties;
return cr;
default:
var cid = centroid(geojson);
cid.properties = properties;
return cid;
}
}
/**
* Takes a feature and returns a {@link Point} guaranteed to be on the surface of the feature.
*
* * Given a {@link Polygon}, the point will be in the area of the polygon
* * Given a {@link LineString}, the point will be along the string
* * Given a {@link Point}, the point will the same as the input
*
* @param {(Feature|FeatureCollection)} fc any feature or set of features
* @returns {Feature} a point on the surface of `input`
* @example
* // create a random polygon
* var polygon = turf.random('polygon');
*
* var pointOnPolygon = turf.pointOnSurface(polygon);
*
* //addToMap
* var addToMap = [polygon, pointOnPolygon];
*/
function pointOnSurface(fc) {
// normalize
if (fc.type !== 'FeatureCollection') {
if (fc.type !== 'Feature') {
fc = {
type: 'Feature',
geometry: fc,
properties: {}
};
}
fc = featureCollection([fc]);
}
//get centroid
var cent = centroid(fc);
// check to see if centroid is on surface
var onSurface = false;
var i = 0;
while (!onSurface && i < fc.features.length) {
var geom = fc.features[i].geometry;
var x, y, x1, y1, x2, y2, k;
var onLine = false;
if (geom.type === 'Point') {
if (cent.geometry.coordinates[0] === geom.coordinates[0] &&
cent.geometry.coordinates[1] === geom.coordinates[1]) {
onSurface = true;
}
} else if (geom.type === 'MultiPoint') {
var onMultiPoint = false;
k = 0;
while (!onMultiPoint && k < geom.coordinates.length) {
if (cent.geometry.coordinates[0] === geom.coordinates[k][0] &&
cent.geometry.coordinates[1] === geom.coordinates[k][1]) {
onSurface = true;
onMultiPoint = true;
}
k++;
}
} else if (geom.type === 'LineString') {
k = 0;
while (!onLine && k < geom.coordinates.length - 1) {
x = cent.geometry.coordinates[0];
y = cent.geometry.coordinates[1];
x1 = geom.coordinates[k][0];
y1 = geom.coordinates[k][1];
x2 = geom.coordinates[k + 1][0];
y2 = geom.coordinates[k + 1][1];
if (pointOnSegment(x, y, x1, y1, x2, y2)) {
onLine = true;
onSurface = true;
}
k++;
}
} else if (geom.type === 'MultiLineString') {
var j = 0;
while (j < geom.coordinates.length) {
onLine = false;
k = 0;
var line = geom.coordinates[j];
while (!onLine && k < line.length - 1) {
x = cent.geometry.coordinates[0];
y = cent.geometry.coordinates[1];
x1 = line[k][0];
y1 = line[k][1];
x2 = line[k + 1][0];
y2 = line[k + 1][1];
if (pointOnSegment(x, y, x1, y1, x2, y2)) {
onLine = true;
onSurface = true;
}
k++;
}
j++;
}
} else if (geom.type === 'Polygon' || geom.type === 'MultiPolygon') {
var f = {
type: 'Feature',
geometry: geom,
properties: {}
};
if (inside(cent, f)) {
onSurface = true;
}
}
i++;
}
if (onSurface) {
return cent;
} else {
var vertices = featureCollection([]);
for (i = 0; i < fc.features.length; i++) {
vertices.features = vertices.features.concat(explode(fc.features[i]).features);
}
var closestVertex;
var closestDistance = Infinity;
for (i = 0; i < vertices.features.length; i++) {
var dist = distance(cent, vertices.features[i], 'miles');
if (dist < closestDistance) {
closestDistance = dist;
closestVertex = vertices.features[i];
}
}
return closestVertex;
}
}