예제 #1
0
    def __init__(self, shell=None, holes=None):
        """
        Parameters
        ----------
        shell : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples
        holes : sequence
            A sequence of objects which satisfy the same requirements as the
            shell parameters above

        Example
        -------
        Create a square polygon with no holes

          >>> coords = ((0., 0.), (0., 1.), (1., 1.), (1., 0.), (0., 0.))
          >>> polygon = Polygon(coords)
          >>> polygon.area
          1.0
        """
        BaseGeometry.__init__(self)

        if shell is not None:
            ret = geos_polygon_from_py(shell, holes)
            if ret is not None:
                self._geom, self._ndim = ret
            else:
                self.empty()
예제 #2
0
    def __init__(self, coordinates=None):
        """Initialize.

        Parameters
        ----------
        
        coordinates : sequence
            Contains coordinate sequences or objects that provide the numpy
            array protocol, providing an M x 2 or M x 3 (with z) array.

        Example
        -------

        >>> geom = MultiLineString( [[[0.0, 0.0], [1.0, 2.0]]] )
        >>> geom = MultiLineString( [ array([[0.0, 0.0], [1.0, 2.0]]) ] )
        
        Each result in a collection containing one line string.
        """
        BaseGeometry.__init__(self)

        if coordinates is None:
            # allow creation of null lines, to support unpickling
            pass
        else:
            self._geom, self._ndim = geos_multilinestring_from_py(coordinates)
예제 #3
0
파일: multipoint.py 프로젝트: 52North/glaps
    def __init__(self, coordinates=None):
        """Initialize.

        Parameters
        ----------
        
        coordinates : sequence or array
            This may be an object that satisfies the numpy array protocol,
            providing an M x 2 or M x 3 (with z) array, or it may be a sequence
            of x, y (,z) coordinate sequences.

        Example
        -------

        >>> geom = MultiPoint([[0.0, 0.0], [1.0, 2.0]])
        >>> geom = MultiPoint(array([[0.0, 0.0], [1.0, 2.0]]))
        
        Each result in a line string from (0.0, 0.0) to (1.0, 2.0).
        """
        BaseGeometry.__init__(self)

        if coordinates is None:
            # allow creation of null lines, to support unpickling
            pass
        else:
            self._geom, self._ndim = geos_multipoint_from_py(coordinates)
예제 #4
0
def assert_shapes_mostly_equal(
    shape1: BaseGeometry, shape2: BaseGeometry, threshold: float
):
    __tracebackhide__ = operator.methodcaller("errisinstance", AssertionError)

    # Check area first, as it's a nicer error message when they're wildly different.
    assert shape1.area == pytest.approx(
        shape2.area, abs=threshold
    ), "Shapes have different areas"

    s1 = shape1.simplify(tolerance=threshold)
    s2 = shape2.simplify(tolerance=threshold)
    assert (s1 - s2).area < threshold, f"{s1} is not mostly equal to {s2}"
예제 #5
0
파일: point.py 프로젝트: aashish24/Shapely
    def __init__(self, *args):
        """
        Parameters
        ----------
        There are 2 cases:

        1) 1 parameter: this must satisfy the numpy array protocol.
        2) 2 or more parameters: x, y, z : float
            Easting, northing, and elevation.
        """
        BaseGeometry.__init__(self)
        if len(args) > 0:
            self._set_coords(*args)
예제 #6
0
파일: point.py 프로젝트: volter/Shapely
    def __init__(self, *args):
        """
        Parameters
        ----------
        There are 2 cases:

        1) 1 parameter: this must satisfy the numpy array protocol.
        2) 2 or more parameters: x, y, z : float
            Easting, northing, and elevation.
        """
        BaseGeometry.__init__(self)
        if len(args) > 0:
            self._set_coords(*args)
예제 #7
0
        def target(x, pattern: BaseGeometry, pos: BaseGeometry):
            params = _TargetTransformParams(x[0], x[1], x[2], x[3])
            pos_trans = _target_affine_transform(pos, params)

            neg = box(*pos_trans.bounds).difference(pos_trans)
            # neg = box(*pos.bounds).difference(pos)
            # neg_trans = _target_affine_transform(neg, params)
            pos_overlap = pattern.intersection(pos_trans).area
            neg_overlap = pattern.intersection(neg).area
            false_pos_overlap = pos_trans.difference(pattern).area
            # return neg_overlap+false_pos_overlap-pos_overlap
            return false_pos_overlap - 2.0 * pos_overlap + neg_overlap + 0.1 * abs(
                x[0]) + 0.1 * abs(x[1])
예제 #8
0
    def polygon_into_geohash(self, geo: BaseGeometry, accuracy: int = 7) -> list:
        """
        将多边形切割成固定精度的多个geohash块,将其按照位置输出成矩阵

        Parameters
        ----------
        geo : shapely.geometry.base.BaseGeometry
            目标多边形
        accuracy : int, optional
            Geohash的精度,默认为7

        Returns
        ----------
        list
            分割出的geohash字符串列表

        Examples
        ----------
        >>> g = GeohashOperator()
        >>> p = Polygon([[116.40233516693117, 39.95442126877703], [116.40233516693117, 39.95744689749303], [116.4070386902313, 39.95744689749303], [116.4070386902313, 39.95442126877703]])
        >>> g.polygon_into_geohash(p)
        [['wx4g2f1', 'wx4g2f4', 'wx4g2f5', 'wx4g2fh', 'wx4g2fj'],
        ['wx4g2cc', 'wx4g2cf', 'wx4g2cg', 'wx4g2cu', 'wx4g2cv'],
        ['wx4g2c9', 'wx4g2cd', 'wx4g2ce', 'wx4g2cs', 'wx4g2ct'],
        ['wx4g2c3', 'wx4g2c6', 'wx4g2c7', 'wx4g2ck', 'wx4g2cm']]

        See Also
        ----------
        nearby_geohash : 求解周边的geohash块编码
        geohash_to_polygon : 将Geohash字符串转成矩形
        geohash_lonlac : 求geohash字符串的边界经度/维度
        """
        boundary = geo.bounds
        geo_list, line_geohash = [], []
        horizontal_geohash = vertical_geohash = geohash.encode(boundary[1], boundary[0], accuracy)
        while True:
            vertical_geohash_polygon = self.geohash_to_polygon(vertical_geohash)
            if geo.contains(vertical_geohash_polygon) or geo.intersects(vertical_geohash_polygon):
                line_geohash.append(vertical_geohash)
                vertical_geohash = self.nearby_geohash(str(vertical_geohash), 3)
            elif self.geohash_lonlac(vertical_geohash, 'w') < boundary[2]:
                vertical_geohash = self.nearby_geohash(str(vertical_geohash), 3)
            else:
                if line_geohash:
                    geo_list.append(line_geohash)
                    line_geohash = []
                horizontal_geohash = vertical_geohash = self.nearby_geohash(horizontal_geohash, 1)
                horizontal_geohash_polygon = self.geohash_to_polygon(horizontal_geohash)
                if not (geo.contains(horizontal_geohash_polygon) or geo.intersects(horizontal_geohash_polygon) or (
                        self.geohash_lonlac(horizontal_geohash, 's') < boundary[3])):
                    return geo_list[::-1]
예제 #9
0
def make_geom(geo_frame, voronoi_frame):
    #new columns to add
    voronoi_frame['area'] = None

    #create full continent of europe
    euro_geoms = [
        geo_frame.loc[index]['geometry'] for index in range(len(geo_frame))
    ]
    all_europe = unary_union(euro_geoms)

    #test to see if voronoi shapes intersect with the europe shape
    for index in range(len(voronoi_frame)):
        current_shape = voronoi_frame.loc[index]['points']
        intersect = BaseGeometry.intersection(all_europe.buffer(0),
                                              current_shape.buffer(0))
        voronoi_frame.loc[index, 'geometry'] = intersect
        voronoi_frame.loc[index, 'area'] = intersect.area

    #there is always an error where index 39 should be a part of norway (index 40)
    nshape = voronoi_frame.loc[40]['geometry']
    missing_part = voronoi_frame.loc[39]['geometry']

    voronoi_frame.loc[40]['geometry'] = unary_union([nshape, missing_part])
    voronoi_frame.loc[39] = None

    return voronoi_frame
예제 #10
0
def test_missing_values_empty_warning():
    s = GeoSeries([Point(1, 1), None, np.nan, BaseGeometry(), Polygon()])
    with pytest.warns(UserWarning):
        s.isna()

    with pytest.warns(UserWarning):
        s.notna()
예제 #11
0
def flatten_geometry(geometry: BaseGeometry) -> BaseGeometry:
    """
    :param geometry: Shapely geometry object
    :return: geometry with Z values removed
    """

    geometry_type = type(geometry)

    # strip 3rd dimension
    if 'POLYGON Z' in geometry.wkt:
        polygons = ([polygon for polygon in geometry]
                    if geometry_type is MultiPolygon else [geometry])
        for polygon_index, polygon in enumerate(polygons):
            exterior_2d = LinearRing(
                [vertex[:2] for vertex in polygon.exterior.coords])
            interiors_2d = [
                LinearRing([vertex[:2] for vertex in interior.coords])
                for interior in polygon.interiors
            ]
            polygons[polygon_index] = Polygon(exterior_2d, interiors_2d)
        geometry = (MultiPolygon(polygons)
                    if geometry_type is MultiPolygon else Polygon(polygons[0]))

    if not geometry.is_valid:
        geometry = geometry.buffer(0)
    return geometry
예제 #12
0
 def decompose(self, geometry: BaseGeometry) -> List[LineString]:
     geometry = geometry.simplify(self._simplify_distance)
     if isinstance(geometry, Polygon):
         return self.decompose_polygon(polygon=geometry)
     elif isinstance(geometry, MultiPolygon):
         lines_list: List[List[LineString]] = [
             self.decompose_polygon(polygon=sub_polygon)
             for sub_polygon in list(geometry)
         ]
         return list(chain.from_iterable(lines_list))
     elif isinstance(geometry, LinearRing):
         return self.decompose_linearRing(ring=geometry)
     elif isinstance(geometry, LineString):
         return self.decompose_lineString(lineString=geometry)
     elif isinstance(geometry, MultiLineString):
         lines_list: List[List[LineString]] = [
             self.decompose_lineString(lineString=sub_lineString)
             for sub_lineString in list(geometry)
         ]
         return list(chain.from_iterable(lines_list))
     elif isinstance(geometry, GeometryCollection):
         lines_list: List[List[LineString]] = [
             self.decompose(geometry=sub_geometry)
             for sub_geometry in list(geometry)
         ]
         return list(chain.from_iterable(lines_list))
     else:
         return []
def find_shape_in_index(shape: BaseGeometry, index):
    # (minx, miny, maxx, maxy)
    bounds = shape.bounds

    lon = []
    lat = []
    weights = []

    for result in index.intersection(bounds, objects="raw"):
        point = result['point']
        rect = result['bbox']
        poly = Polygon([(r[0], r[1]) for r in rect])

        inters = shape.intersection(poly)
        # Intersection with bounds might not intersect with detailed poly
        if inters:
            weights.append(inters.area)
            lon.append(point[0])
            lat.append(point[1])

    lon = np.array(lon)
    lat = np.array(lat)
    weights = np.array(weights)
    weights = weights / np.sum(weights)
    return GridLookupResults(lon, lat, weights)
예제 #14
0
def stretch_contour(geom: BaseGeometry, width: float = 1) -> BaseGeometry:
    """
    Stretch geometry (expected to be a geometry contour) to given width scale.
    """
    if width > 1 and geom:
        buf = 1 + (width - 1) / 10
        return geom.buffer(buf)
    return geom
예제 #15
0
 def fillna(self, value=None):
     """ Fill NA/NaN values with a geometry (empty polygon by default) """
     if value is None:
         value = BaseGeometry()
     return GeoSeries(self._geometry_array.fillna(value),
                      index=self.index,
                      crs=self.crs,
                      name=self.name)
예제 #16
0
    def test_align_mixed(self):
        a1 = self.a1
        s2 = pd.Series([1, 2], index=['B', 'C'])
        res1, res2 = a1.align(s2)

        exp2 = pd.Series([BaseGeometry(), 1, 2],
                         dtype=object,
                         index=['A', 'B', 'C'])
        assert_series_equal(res2, exp2)
예제 #17
0
    def to_bytes(cls, geom: BaseGeometry) -> List[int]:
        geom_name = str(geom.__class__.__name__).lower()

        try:
            appr_parser = PARSERS[geom_name]
            geom.__UDT__ = GeometryType()
        except KeyError:
            raise KeyError(f"Parser for geometry {geom_name} is not available")
        return appr_parser.serialize(geom, BinaryBuffer())
예제 #18
0
 def align(self, other, join='outer', level=None, copy=True,
           fill_value=None, **kwargs):
     if fill_value is None:
         fill_value = BaseGeometry()
     left, right = super(GeoSeries, self).align(other, join=join,
                                                level=level, copy=copy,
                                                fill_value=fill_value,
                                                **kwargs)
     return left, right
예제 #19
0
 def __get_tmp_res(self, res: set, intersect_geohash: str, test_poly: BaseGeometry, tmp_precision: int,
                   stop_precision: int, intersect: bool):
     geohash_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k',
                     'm', 'n', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
     tmp_precision += 1
     for add_on in geohash_list:
         tmp_poly = self.geohash_to_polygon(intersect_geohash + add_on)
         if test_poly.contains(tmp_poly):
             res.add(intersect_geohash + add_on)
         elif test_poly.intersects(tmp_poly):
             if tmp_precision == stop_precision:
                 if intersect is True:
                     res.add(intersect_geohash + add_on)
             else:
                 res = res.union(
                     self.__get_tmp_res(res, intersect_geohash + add_on, test_poly, tmp_precision, stop_precision,
                                        intersect)
                 )
     return res
예제 #20
0
파일: polygon.py 프로젝트: 52North/glaps
    def __init__(self, shell=None, holes=None):
        """Initialize.

        Parameters
        ----------
        exterior : sequence or array
            This may be an object that satisfies the numpy array protocol,
            providing an M x 2 or M x 3 (with z) array, or it may be a sequence
            of x, y (,z) coordinate sequences.

        Example
        -------
        >>> coords = ((0., 0.), (0., 1.), (1., 1.), (1., 0.), (0., 0.))
        >>> polygon = Polygon(coords)
        """
        BaseGeometry.__init__(self)

        if shell is not None:
            self._geom, self._ndim = geos_polygon_from_py(shell, holes)
예제 #21
0
    def unary_union(self):
        attr = "unary_union"
        meta = BaseGeometry()

        return self.reduction(
            lambda x: getattr(x, attr),
            token=f"{self._name}-{attr}",
            aggregate=lambda x: getattr(geopandas.GeoSeries(x), attr),
            meta=meta,
        )
예제 #22
0
 def convex_hull(self):
     """Convex hull of union of all objects in the field."""
     field = BaseGeometry()
     if self.obstacles:
         field |= self.obstacles
     if self.targets:
         field |= union(*self.targets)
     if self.spawns:
         field |= union(*self.spawns)
     return field.convex_hull
예제 #23
0
    def fillna(self, value=None, method=None, inplace=False,
               **kwargs):
        """Fill NA/NaN values with a geometry (empty polygon by default).

        "method" is currently not implemented for pandas <= 0.12.
        """
        if value is None:
            value = BaseGeometry()
        return super(GeoSeries, self).fillna(value=value, method=method,
                                             inplace=inplace, **kwargs)
예제 #24
0
    def __init__(self, coordinates=None):
        """
        Parameters
        ----------
        coordinates : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples or
            an object that provides the numpy array interface, including
            another instance of LineString.

        Example
        -------
        Create a line with two segments

          >>> a = LineString([[0, 0], [1, 0], [1, 1]])
          >>> a.length
          2.0
        """
        BaseGeometry.__init__(self)
        if coordinates is not None:
            self._set_coords(coordinates)
예제 #25
0
    def __init__(self, coordinates=None):
        """
        Parameters
        ----------
        coordinates : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples or
            an object that provides the numpy array interface, including
            another instance of LineString.

        Example
        -------
        Create a line with two segments

          >>> a = LineString([[0, 0], [1, 0], [1, 1]])
          >>> a.length
          2.0
        """
        BaseGeometry.__init__(self)
        if coordinates is not None:
            self._set_coords(coordinates)
예제 #26
0
    def __init__(self, *args):
        """
        Parameters
        ----------
        There are 2 cases:

        1) 1 parameter: this must satisfy the numpy array protocol.
        2) 2 or more parameters: x, y, z : float
            Easting, northing, and elevation.
        """
        BaseGeometry.__init__(self)
        if len(args) > 0:
            if len(args) == 1:
                self._geom, self._ndim = geos_point_from_py(args[0])
            elif len(args) > 3:
                raise TypeError(
                    "Point() takes at most 3 arguments ({} given)".format(
                        len(args)))
            else:
                self._geom, self._ndim = geos_point_from_py(tuple(args))
예제 #27
0
def test_read_carto_basegeometry_as_null_geom_value(mocker):
    # Given
    cm_mock = mocker.patch.object(ContextManager, 'copy_to')
    cm_mock.return_value = GeoDataFrame({
        'cartodb_id': [1],
        'the_geom': [None]
    })

    # When
    gdf = read_carto('__source__', CREDENTIALS, null_geom_value=BaseGeometry())

    # Then
    expected = GeoDataFrame({
        'cartodb_id': [1],
        'the_geom': [BaseGeometry()]
    },
                            geometry='the_geom')

    cm_mock.assert_called_once_with('__source__', None, None, 3)
    assert expected.equals(gdf)
    assert gdf.crs == 'epsg:4326'
 def align(self, other, join='outer', level=None, copy=True,
           fill_value=None, **kwargs):
     if fill_value is None:
         fill_value = BaseGeometry()
     left, right = super(GeoSeries, self).align(other, join=join,
                                                level=level, copy=copy,
                                                fill_value=fill_value,
                                                **kwargs)
     if isinstance(other, GeoSeries):
         return GeoSeries(left), GeoSeries(right)
     else: # It is probably a Series, let's keep it that way
         return GeoSeries(left), right
예제 #29
0
파일: polygon.py 프로젝트: 52North/glaps
    def __init__(self, coordinates=None):
        """Initialize.

        Parameters
        ----------
        coordinates : sequence or array
            This may be an object that satisfies the numpy array protocol,
            providing an M x 2 or M x 3 (with z) array, or it may be a sequence
            of x, y (,z) coordinate sequences.

        Rings are implicitly closed. There is no need to specific a final
        coordinate pair identical to the first.

        Example
        -------
        >>> ring = LinearRing( ((0.,0.), (0.,1.), (1.,1.), (1.,0.)) )

        Produces a 1x1 square.
        """
        BaseGeometry.__init__(self)
        self._init_geom(coordinates)
예제 #30
0
파일: linestring.py 프로젝트: 52North/glaps
    def __init__(self, coordinates=None):
        """Initialize.

        Parameters
        ----------
        
        coordinates : sequence or array
            This may be an object that satisfies the numpy array protocol,
            providing an M x 2 or M x 3 (with z) array, or it may be a sequence
            of x, y (,z) coordinate sequences.

        Example
        -------

        >>> line = LineString([[0.0, 0.0], [1.0, 2.0]])
        >>> line = LineString(array([[0.0, 0.0], [1.0, 2.0]]))
        
        Each result in a line string from (0.0, 0.0) to (1.0, 2.0).
        """
        BaseGeometry.__init__(self)
        self._init_geom(coordinates)
예제 #31
0
def is_similar(geom1: BaseGeometry, geom2: BaseGeometry, eps: float = 1e-6) -> bool:
    if type(geom1) is not type(geom2):
        return False

    if isinstance(geom1, (LineString, MultiLineString, Point, MultiPoint)):
        return (geom1.buffer(eps).contains(geom2)
                and geom2.buffer(eps).contains(geom1))

    if isinstance(geom1, (Polygon, MultiPolygon)):
        return geom1.symmetric_difference(geom2).area < eps

    if isinstance(geom1, GeometryCollection):
        polygons1, non_polygons1 = separate(geom1, lambda geom: isinstance(geom, Polygon))
        polygons2, non_polygons2 = separate(geom2, lambda geom: isinstance(geom, Polygon))
        polygon_union1 = unary_union(polygons1)
        non_polygon_union1 = unary_union(non_polygons1)
        polygon_union2 = unary_union(polygons2)
        non_polygon_union2 = unary_union(non_polygons2)
        return (polygon_union1.symmetric_difference(polygon_union2).area < eps
                and non_polygon_union1.buffer(eps).contains(non_polygon_union2)
                and non_polygon_union2.buffer(eps).contains(non_polygon_union1))
예제 #32
0
    def create_jvm_geometry_from_base_geometry(cls, jvm, geom: BaseGeometry):
        """
        :param jvm:
        :param geom:
        :return:
        """
        if isinstance(geom, Envelope):
            jvm_geom = geom.create_jvm_instance(jvm)
        else:
            decoded_geom = GeometryFactory.to_bytes(geom)
            jvm_geom = jvm.GeometryAdapter.deserializeToGeometry(decoded_geom)

        return jvm_geom
예제 #33
0
    def create_jvm_geometry_from_base_geometry(cls, jvm, geom: BaseGeometry):
        """
        :param jvm:
        :param geom:
        :return:
        """
        if isinstance(geom, Envelope):
            jvm_geom = geom.create_jvm_instance(jvm)
        else:
            decoded_geom = GeometryFactory.to_bytes(geom)
            jvm_geom = JvmGeometryAdapter(jvm).translate_to_java(decoded_geom)

        return jvm_geom
예제 #34
0
    def __init__(self, coordinates=None):
        """
        Parameters
        ----------
        coordinates : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples

        Rings are implicitly closed. There is no need to specific a final
        coordinate pair identical to the first.

        Example
        -------
        Construct a square ring.

          >>> ring = LinearRing( ((0, 0), (0, 1), (1 ,1 ), (1 , 0)) )
          >>> ring.is_closed
          True
          >>> ring.length
          4.0
        """
        BaseGeometry.__init__(self)
        if coordinates is not None:
            self._set_coords(coordinates)
예제 #35
0
    def __init__(self, shell=None, holes=None):
        """
        Parameters
        ----------
        shell : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples
        holes : sequence
            A sequence of objects which satisfy the same requirements as the
            shell parameters above

        Example
        -------
        Create a square polygon with no holes

          >>> coords = ((0., 0.), (0., 1.), (1., 1.), (1., 0.), (0., 0.))
          >>> polygon = Polygon(coords)
          >>> polygon.area
          1.0
        """
        BaseGeometry.__init__(self)

        if shell is not None:
            self._geom, self._ndim = geos_polygon_from_py(shell, holes)
예제 #36
0
    def __init__(self, coordinates=None):
        """
        Parameters
        ----------
        coordinates : sequence
            A sequence of (x, y [,z]) numeric coordinate pairs or triples

        Rings are implicitly closed. There is no need to specific a final
        coordinate pair identical to the first.

        Example
        -------
        Construct a square ring.

          >>> ring = LinearRing( ((0, 0), (0, 1), (1 ,1 ), (1 , 0)) )
          >>> ring.is_closed
          True
          >>> ring.length
          4.0
        """
        BaseGeometry.__init__(self)
        if coordinates is not None:
            self._set_coords(coordinates)
예제 #37
0
def subtract_turbine_exclusion_zone(min_spacing: float,
                                    source_shape: BaseGeometry,
                                    turbine_positions: [Point],
                                    ) -> BaseGeometry:
    """
    Subtract the min spacing around each turbine from a site polygon
    :param min_spacing: minimum distance around turbine
    :param source_shape: site polygon
    :param turbine_positions: Points of the turbines within the source_shape
    :return: modified shape with the circles around the turbines removed
    """
    if len(turbine_positions) <= 0:
        return source_shape
    return source_shape.difference(
        unary_union([turbine.buffer(min_spacing) for turbine in turbine_positions]))
예제 #38
0
def make_geoms(vframe, geo_frame):
    vframe['geometry'] = None
    poly = geo_frame.unary_union

    for index in range(135):
        try:
            loop_geom = BaseGeometry.intersection(
                vframe.loc[index]['points'].buffer(0), poly.buffer(0))
            vframe.loc[index, 'geometry'] = loop_geom
        except:
            True

    #set projection as mercator for the new data frame
    vframe.crs = {'init': 'epsg = 3395'}

    return vframe
예제 #39
0
def interpolate(geometry: BaseGeometry,
                gap: float,
                simplify_distance: float = 1e-6) -> BaseGeometry:
    def interpolate_coords(coords):
        new_coords: List[Tuple[float, float]] = []
        for i in range(len(coords) - 2):
            new_coords.extend(
                interpolate_coords_by_len(coords[i],
                                          coords[i + 1],
                                          gap,
                                          result_include_coord2=False))
        new_coords.extend(
            interpolate_coords_by_len(coords[-2],
                                      coords[-1],
                                      gap,
                                      result_include_coord2=True))
        return new_coords

    if isinstance(geometry, (Point, MultiPoint)):
        return geometry
    elif isinstance(geometry, (Polygon, LineString, LinearRing)):
        geometry_simplified = geometry.simplify(simplify_distance)
        if isinstance(geometry, Polygon):
            exterior_coords = list(geometry_simplified.exterior.coords)
            interior_coords_list = [
                list(interior.coords)
                for interior in geometry_simplified.interiors
            ]
            interpolated_exterior = interpolate_coords(exterior_coords)
            interpolated_interiors = [
                interpolate_coords(interior_coords)
                for interior_coords in interior_coords_list
            ]
            return Polygon(shell=interpolated_exterior,
                           holes=interpolated_interiors)
        else:  # LineString or LinearRing
            coords = list(geometry_simplified.coords)
            return type(geometry)(interpolate_coords(coords))
    elif isinstance(geometry,
                    (MultiPolygon, MultiLineString, GeometryCollection)):
        geoms = list(geometry)
        interpolated_geoms = [interpolate(geom, gap) for geom in geoms]
        return type(geometry)(interpolated_geoms)

    return geometry  # return origin geometry if not match any type
예제 #40
0
 def test_none_geom(self):
     p = BaseGeometry()
     p._geom = None
     self.assertTrue(p.is_empty)
예제 #41
0
 def test_none_geom(self):
     p = BaseGeometry()
     p._geom = None
     self.failUnless(p.is_empty, True)