def explode(geojson):
points = []
if geojson["type"] == "FeatureCollection":
def _callback_feature_each(feature, feature_index):
def _callback_coord_each(
coord, coord_index, feature_index, multi_feature_index, geometry_index,
):
nonlocal points
point = Point(coord)
points.append(Feature(geometry=point, properties=feature["properties"]))
coord_each(feature, _callback_coord_each)
feature_each(geojson, _callback_feature_each)
else:
def _callback_coord_each(
coord, coord_index, feature_index, multi_feature_index, geometry_index,
):
nonlocal points, geojson
point = Point(coord)
points.append(Feature(geometry=point, properties=geojson["properties"]))
coord_each(geojson, _callback_coord_each)
return FeatureCollection(points)
def transform_scale(
features,
factor: float,
origin: Union[str, list] = "centroid",
mutate: bool = False,
):
"""
Scale a GeoJSON from a given
point by a factor of scaling
(ex: factor=2 would make the GeoJSON 200% larger).
If a FeatureCollection is provided, the origin
point will be calculated based on each individual Feature.
:param features: GeoJSON to be scaled
:param factor: of scaling, positive or negative values greater than 0
:param origin: Point from which the scaling will occur
(string options: sw/se/nw/ne/center/centroid)
:param mutate: allows GeoJSON input to be mutated
(significant performance increase if true)
:return: Scaled Geojson
Example :-
>>> from turfpy.transformation import transform_scale
>>> from geojson import Polygon, Feature
>>> f = Feature(geometry=Polygon([[[0,29],[3.5,29],[2.5,32],[0,29]]]))
>>> transform_scale(f, 3, origin=[0, 29])
"""
if not features:
raise Exception("geojson is required")
if not factor:
raise Exception("invalid factor")
if not mutate:
features = copy.deepcopy(features)
if features["type"] == "FeatureCollection":
def _callback_feature_each(feature, feature_index):
nonlocal factor, origin, features
features["features"][feature_index] = scale(
feature, factor, origin)
feature_each(features, _callback_feature_each)
return features
return scale(features, factor, origin)
def nearest_point(target_point: Feature, points: FeatureCollection) -> Feature:
"""
Takes a reference Point Feature and FeatureCollection of point features and returns
the point from the FeatureCollection closest to the reference Point Feature.
:param target_point: Feature Point of reference.
:param points: FeatureCollection of points.
:return: a Point Feature from the FeatureCollection which is closest to the reference
Point.
Example:
>>> from turfpy.measurement import nearest_point
>>> from geojson import Point, Feature, FeatureCollection
>>> f1 = Feature(geometry=Point((28.96991729736328,41.01190001748873)))
>>> f2 = Feature(geometry=Point((28.948459, 41.024204)))
>>> f3 = Feature(geometry=Point((28.938674, 41.013324)))
>>> fc = FeatureCollection([f1, f2 ,f3])
>>> t = Feature(geometry=Point((28.973865, 41.011122)))
>>> nearest_point(t ,fc)
"""
if not target_point:
raise Exception("target_point is required")
if not points:
raise Exception("points is required")
min_dist = float("inf")
best_feature_index = 0
def _callback_feature_each(pt, feature_index):
nonlocal min_dist, best_feature_index
distance_to_point = distance(target_point, pt)
if float(distance_to_point) < min_dist:
best_feature_index = feature_index
min_dist = distance_to_point
return True
feature_each(points, _callback_feature_each)
nearest = points["features"][best_feature_index]
nearest["properties"]["featureIndex"] = best_feature_index
nearest["properties"]["distanceToPoint"] = min_dist
return nearest
def points_within_polygon(
points: Union[Feature, FeatureCollection],
polygons: Union[Feature, FeatureCollection]) -> FeatureCollection:
"""Find Point(s) that fall within (Multi)Polygon(s).
This function takes two inputs GeoJSON Feature :class:`geojson.Point` or
:class:`geojson.FeatureCollection` of Points and GeoJSON Feature
:class:`geojson.Polygon` or Feature :class:`geojson.MultiPolygon` or
FeatureCollection of :class:`geojson.Polygon` or Feature
:class:`geojson.MultiPolygon`. and returns all points with in in those
Polygon(s) or (Multi)Polygon(s).
:param points: A single GeoJSON ``Point`` feature or FeatureCollection of Points.
:param polygons: A Single GeoJSON Polygon/MultiPolygon or FeatureCollection of
Polygons/MultiPolygons.
:return: A :class:`geojson.FeatureCollection` of Points.
"""
results = []
def __callback_feature_each(feature, feature_index):
contained = False
def __callback_geom_each(current_geometry, feature_index,
feature_properties, feature_bbox, feature_id):
if boolean_point_in_polygon(feature, current_geometry):
nonlocal contained
contained = True
if contained:
nonlocal results
results.append(feature)
geom_each(polygons, __callback_geom_each)
return True
feature_each(points, __callback_feature_each)
return FeatureCollection(results)
