/** * Takes a set of features, calculates the bbox of all input features, and returns a bounding box. * * @name bbox * @param {(Feature|FeatureCollection)} geojson input features * @return {Array<number>} bbox extent in [minX, minY, maxX, maxY] order * @example * var pt1 = point([114.175329, 22.2524]) * var pt2 = point([114.170007, 22.267969]) * var pt3 = point([114.200649, 22.274641]) * var pt4 = point([114.200649, 22.274641]) * var pt5 = point([114.186744, 22.265745]) * var features = featureCollection([pt1, pt2, pt3, pt4, pt5]) * * var bbox = turf.bbox(features); * * var bboxPolygon = turf.bboxPolygon(bbox); * * //=bbox * * //=bboxPolygon */ public static List <double> Bbox(IGeoJSONObject geojson) { var bbox = new List <double>() { double.PositiveInfinity, double.PositiveInfinity, double.NegativeInfinity, double.NegativeInfinity }; Turf.CoordEach(geojson, (List <double> coord) => { if (bbox[0] > coord[0]) { bbox[0] = coord[0]; } if (bbox[1] > coord[1]) { bbox[1] = coord[1]; } if (bbox[2] < coord[0]) { bbox[2] = coord[0]; } if (bbox[3] < coord[1]) { bbox[3] = coord[1]; } }); return(bbox); }
static public void CoordEach(IGeoJSONObject layer, Action <GeographicPosition> callback, bool excludeWrapCoord = false) { var isFeatureCollection = layer.Type == GeoJSONObjectType.FeatureCollection; var isFeature = layer.Type == GeoJSONObjectType.Feature; var stop = isFeatureCollection ? ((FeatureCollection)layer).Features.Count : 1; // This logic may look a little weird. The reason why it is that way // is because it's trying to be fast. GeoJSON supports multiple kinds // of objects at its root: FeatureCollection, Features, Geometries. // This function has the responsibility of handling all of them, and that // means that some of the `for` loops you see below actually just don't apply // to certain inputs. For instance, if you give this just a // Point geometry, then both loops are short-circuited and all we do // is gradually rename the input until it's called 'geometry'. // // This also aims to allocate as few resources as possible: just a // few numbers and booleans, rather than any temporary arrays as would // be required with the normalization approach. for (var i = 0; i < stop; i++) { var geometryMaybeCollection = isFeatureCollection ? (IGeometryObject)((FeatureCollection)layer).Features[i].Geometry : isFeature ? (IGeometryObject)((Feature)layer).Geometry : (IGeometryObject)layer; CoordEach(geometryMaybeCollection, callback, excludeWrapCoord); } }
/** * Takes a {@link Feature} or {@link FeatureCollection} and returns the absolute center point of all features. * * @name center * @param {(Feature|FeatureCollection)} layer input features * @return {Feature<Point>} a Point feature at the absolute center point of all input features * @example * var features = { * "type": "FeatureCollection", * "features": [ * { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.522259, 35.4691] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.502754, 35.463455] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.508269, 35.463245] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.516809, 35.465779] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.515372, 35.467072] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.509363, 35.463053] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.511123, 35.466601] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.518547, 35.469327] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.519706, 35.469659] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.517839, 35.466998] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.508678, 35.464942] * } * }, { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Point", * "coordinates": [-97.514914, 35.463453] * } * } * ] * }; * * var centerPt = turf.center(features); * centerPt.properties['marker-size'] = 'large'; * centerPt.properties['marker-color'] = '#000'; * * var resultFeatures = features.features.concat(centerPt); * var result = { * "type": "FeatureCollection", * "features": resultFeatures * }; * * //=result */ public static Feature Center(IGeoJSONObject layer) { var ext = Bbox(layer); var x = (ext[0] + ext[2]) / 2; var y = (ext[1] + ext[3]) / 2; return(Turf.Point(new double[] { x, y })); }
/** * Takes a feature or set of features and returns all positions as * {@link Point|points}. * * @name explode * @param {(Feature|FeatureCollection)} geojson input features * @return {FeatureCollection<point>} points representing the exploded input features * @throws {Error} if it encounters an unknown geometry type * @example * var poly = { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Polygon", * "coordinates": [[ * [177.434692, -17.77517], * [177.402076, -17.779093], * [177.38079, -17.803937], * [177.40242, -17.826164], * [177.438468, -17.824857], * [177.454948, -17.796746], * [177.434692, -17.77517] * ]] * } * }; * * var points = turf.explode(poly); * * //=poly * * //=points */ public static FeatureCollection Explode(IGeoJSONObject geojson) { var points = new List <Feature>(); CoordEach(geojson, (GeographicPosition coord) => { points.Add(Turf.Point(coord)); }); return(new FeatureCollection(points)); }
/** * Reduce coordinates in any GeoJSON object into a single value, * similar to how Array.reduce works. However, in this case we lazily run * the reduction, so an array of all coordinates is unnecessary. * * @name coordReduce * @param {Object} layer any GeoJSON object * @param {Function} callback a method that takes (memo, value) and returns * a new memo * @param {*} memo the starting value of memo: can be any type. * @param {boolean=} excludeWrapCoord whether or not to include * the final coordinate of LinearRings that wraps the ring in its iteration. * @returns {*} combined value */ static public object CoordReduce(IGeoJSONObject layer, Func <object, GeographicPosition, object> callback, object memo, bool excludeWrapCoord = false) { object ret = memo; Action <GeographicPosition> internal_cb = (GeographicPosition coord) => { ret = callback(ret, coord); }; CoordEach(layer, internal_cb, excludeWrapCoord); return(ret); }
/** * Takes one or more features and calculates the centroid using * the mean of all vertices. * This lessens the effect of small islands and artifacts when calculating * the centroid of a set of polygons. * * @name centroid * @param {(Feature|FeatureCollection)} features input features * @return {Feature<Point>} the centroid of the input features * @example * var poly = { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "Polygon", * "coordinates": [[ * [105.818939,21.004714], * [105.818939,21.061754], * [105.890007,21.061754], * [105.890007,21.004714], * [105.818939,21.004714] * ]] * } * }; * * var centroidPt = turf.centroid(poly); * * var result = { * "type": "FeatureCollection", * "features": [poly, centroidPt] * }; * * //=result */ public static Feature Centroid(IGeoJSONObject features) { double xSum = 0; double ySum = 0; int len = 0; Turf.CoordEach(features, (List <double> coord) => { xSum += coord[0]; ySum += coord[1]; len++; }, true); return(Turf.Point(new double[] { xSum / (double)len, ySum / (double)len })); }
public void Parse_PointStringWithNameCrsExtraParameter_SuccessfulParse() { string strGeometry = "{\"type\": \"Point\",\"coordinates\": [-105.01621,39.57422], \"crs\": {\"type\": \"name\", \"properties\": {\"name\": \"urn:ogc:def:crs:OGC:1.3:CRS84\", \"extra\": [1, 0]}}}"; IGeoJSONObject geoJsonObject = (IGeoJSONObject)JsonConvert.DeserializeObject <IGeometryObject>(strGeometry, new GeometryConverter()); // Assert CRS is parsed Assert.AreEqual(CRSType.Name, geoJsonObject.CRS.Type); NamedCRS namedCrs = (NamedCRS)geoJsonObject.CRS; Assert.AreEqual("urn:ogc:def:crs:OGC:1.3:CRS84", namedCrs.Name); Assert.IsTrue(namedCrs.Properties.ContainsKey("extra")); Assert.IsNotNull(namedCrs.Properties["extra"]); }
public bool UpdateSource(string sourceId, IGeoJSONObject featureCollection) { var source = mapStyle.SourceWithIdentifier(sourceId) as MGLShapeSource; if (source == null) { return(false); } source.Shape = featureCollection.ToShape(); return(true); }
/** * Takes a {@link LineString} or {@link Polygon} and measures its length in the specified units. * * @name lineDistance * @param {Feature<(LineString|Polygon)>|FeatureCollection<(LineString|Polygon)>} line line to measure * @param {string} [units=kilometers] can be degrees, radians, miles, or kilometers * @return {number} length of the input line * @example * var line = { * "type": "Feature", * "properties": {}, * "geometry": { * "type": "LineString", * "coordinates": [ * [-77.031669, 38.878605], * [-77.029609, 38.881946], * [-77.020339, 38.884084], * [-77.025661, 38.885821], * [-77.021884, 38.889563], * [-77.019824, 38.892368] * ] * } * }; * * var length = turf.lineDistance(line, 'miles'); * * //=line * * //=length */ public static double LineDistance(IGeoJSONObject line, string units = "kilometers") { if (line.Type == GeoJSONObjectType.FeatureCollection) { return(((FeatureCollection)line).Features.Aggregate(0, (double memo, Feature feature) => { return memo + LineDistance(feature); })); } var geometry = line.Type == GeoJSONObjectType.Feature ? ((Feature)line).Geometry : (IGeometryObject)line; if (geometry.Type == GeoJSONObjectType.LineString) { return(Length(((LineString)geometry).Coordinates, units)); } else if (geometry.Type == GeoJSONObjectType.Polygon || geometry.Type == GeoJSONObjectType.MultiLineString) { double d = 0; var lines = geometry.Type == GeoJSONObjectType.Polygon ? ((Polygon)geometry).Coordinates : ((MultiLineString)geometry).Coordinates; for (var i = 0; i < lines.Count; i++) { var points = ((LineString)lines[i]).Coordinates; d += Length(points, units); } return(d); } else if (geometry.Type == GeoJSONObjectType.MultiPolygon) { double d = 0; var polygons = ((MultiPolygon)geometry).Coordinates; for (var i = 0; i < polygons.Count; i++) { var lines = ((Polygon)polygons[i]).Coordinates; for (var j = 0; j < lines.Count; j++) { var points = ((LineString)lines[j]).Coordinates; d += Length(points, units); } } return(d); } else { throw new Exception("input must be a LineString, MultiLineString, " + "Polygon, or MultiPolygon Feature or Geometry (or a FeatureCollection " + "containing only those types)"); } }
/** * Iterate over property objects in any GeoJSON object, similar to * Array.forEach. * * @name propEach * @param {Object} layer any GeoJSON object * @param {Function} callback a method that takes (value) * @example * var point = { type: 'Feature', geometry: null, properties: { foo: 1 } }; * propEach(point, function(props) { * // props is equal to { foo: 1} * }); */ static public void PropEach(IGeoJSONObject layer, Action <Dictionary <string, object>, int> callback) { if (layer.Type == GeoJSONObjectType.FeatureCollection) { for (var i = 0; i < ((FeatureCollection)layer).Features.Count; i++) { callback(((FeatureCollection)layer).Features[i].Properties, i); } } else if (layer.Type == GeoJSONObjectType.Feature) { callback(((Feature)layer).Properties, 0); } else { throw new Exception("Feature or FeatureCollection must be given"); } }
public void Parse_PointStringWithLinkCrs_SuccessfulParse() { string strGeometry = "{\"type\": \"Point\",\"coordinates\": [-105.01621,39.57422], \"crs\": {\"type\": \"link\", \"properties\": { \"href\": \"http://example.com/crs/42\", \"type\": \"proj4\"}}}"; IGeoJSONObject geoJsonObject = (IGeoJSONObject)JsonConvert.DeserializeObject <IGeometryObject>(strGeometry, new GeometryConverter()); // Assert CRS is parsed Assert.AreEqual(CRSType.Link, geoJsonObject.CRS.Type); LinkedCRS linkedCrs = (LinkedCRS)geoJsonObject.CRS; Assert.AreEqual("http://example.com/crs/42", linkedCrs.Href); Assert.AreEqual("proj4", linkedCrs.Properties["type"]); // Deserialization without specifying Converter Point point = JsonConvert.DeserializeObject <Point>(strGeometry); // Assert CRS is parsed Assert.AreEqual(CRSType.Link, point.CRS.Type); linkedCrs = (LinkedCRS)point.CRS; Assert.AreEqual("http://example.com/crs/42", linkedCrs.Href); Assert.AreEqual("proj4", linkedCrs.Properties["type"]); }
public void Parse_PointStringWithNameCrs_SuccessfulParse() { string strGeometry = "{\"type\": \"Point\",\"coordinates\": [-105.01621,39.57422], \"crs\": {\"type\": \"name\", \"properties\": {\"name\": \"urn:ogc:def:crs:OGC:1.3:CRS84\"}}}"; IGeometryObject geometryObject = JsonConvert.DeserializeObject <IGeometryObject>(strGeometry, new GeometryConverter()); IGeoJSONObject geoJsonObject = (IGeoJSONObject)geometryObject; // Assert CRS is parsed Assert.AreEqual(CRSType.Name, geoJsonObject.CRS.Type); NamedCRS namedCrs = (NamedCRS)geoJsonObject.CRS; Assert.AreEqual("urn:ogc:def:crs:OGC:1.3:CRS84", namedCrs.Name); // Deserialization without specifying Converter Point point = JsonConvert.DeserializeObject <Point>(strGeometry); // Assert CRS is parsed Assert.AreEqual(CRSType.Name, point.CRS.Type); namedCrs = (NamedCRS)point.CRS; Assert.AreEqual("urn:ogc:def:crs:OGC:1.3:CRS84", namedCrs.Name); }
public bool UpdateSource(string sourceId, IGeoJSONObject geoJsonObject) { var source = mapStyle.GetSource(sourceId) as Com.Mapbox.Mapboxsdk.Style.Sources.GeoJsonSource; if (source == null) { return(false); } var json = JsonConvert.SerializeObject(geoJsonObject); switch (geoJsonObject) { case GeoJSON.Net.Feature.Feature feature: source.SetGeoJson(Feature.FromJson(json)); break; default: source.SetGeoJson(FeatureCollection.FromJson(json)); break; } return(true); }
int INpgsqlTypeHandler <IGeoJSONObject> .ValidateAndGetLength(IGeoJSONObject value, ref NpgsqlLengthCache lengthCache, NpgsqlParameter parameter) => ValidateAndGetLength((GeoJSONObject)value, ref lengthCache, parameter);
public GeoJsonSource(string id, IGeoJSONObject data) { Id = id; Data = data; }
/** * Takes any number of features and returns a rectangular {@link Polygon} that encompasses all vertices. * * @name envelope * @param {(Feature|FeatureCollection)} features input features * @return {Feature<Polygon>} a rectangular Polygon feature that encompasses all vertices * @example * var fc = { * "type": "FeatureCollection", * "features": [ * { * "type": "Feature", * "properties": { * "name": "Location A" * }, * "geometry": { * "type": "Point", * "coordinates": [-75.343, 39.984] * } * }, { * "type": "Feature", * "properties": { * "name": "Location B" * }, * "geometry": { * "type": "Point", * "coordinates": [-75.833, 39.284] * } * }, { * "type": "Feature", * "properties": { * "name": "Location C" * }, * "geometry": { * "type": "Point", * "coordinates": [-75.534, 39.123] * } * } * ] * }; * * var enveloped = turf.envelope(fc); * * var resultFeatures = fc.features.concat(enveloped); * var result = { * "type": "FeatureCollection", * "features": resultFeatures * }; * * //=result */ public static Feature Envelope(IGeoJSONObject features) { return(BboxPolygon(Bbox(features))); }
Task INpgsqlTypeHandler <IGeoJSONObject> .Write(IGeoJSONObject value, NpgsqlWriteBuffer buf, NpgsqlLengthCache lengthCache, NpgsqlParameter parameter, bool async) => Write((GeoJSONObject)value, buf, lengthCache, parameter, async);
/** * Iterate over coordinates in any GeoJSON object, similar to * Array.forEach. * * @name coordEach * @param {Object} layer any GeoJSON object * @param {Function} callback a method that takes (value) * @param {boolean=} excludeWrapCoord whether or not to include * the final coordinate of LinearRings that wraps the ring in its iteration. * @example * var point = { type: 'Point', coordinates: [0, 0] }; * coordEach(point, function(coords) { * // coords is equal to [0, 0] * }); */ static public void CoordEach(IGeoJSONObject layer, Action <List <double> > callback, bool excludeWrapCoord = false) { CoordEach(layer, (GeographicPosition obj) => { callback(GetCoord(obj)); }, excludeWrapCoord); }