コード例 #1
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_affine_3d(self):
     g2 = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     g3 = load_wkt('LINESTRING(2.4 4.1 100.2, 2.4 3 132.8, 3 3 128.6)')
     # custom scale and translate
     matrix2d = (2, 0, 0, 2.5, -5, 4.1)
     matrix3d = (2, 0, 0, 0, 2.5, 0, 0, 0, 0.3048, -5, 4.1, 100)
     # Combinations of 2D and 3D geometries and matrices
     a22 = transform.affine(g2, matrix2d)
     a23 = transform.affine(g2, matrix3d)
     a32 = transform.affine(g3, matrix2d)
     a33 = transform.affine(g3, matrix3d)
     # Check dimensions
     self.assertFalse(a22.has_z)
     self.assertFalse(a23.has_z)
     self.assertTrue(a32.has_z)
     self.assertTrue(a33.has_z)
     # 2D equality checks
     expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
     expected3d = load_wkt('LINESTRING(-0.2 14.35 130.54096, '\
                           '-0.2 11.6 140.47744, 1 11.6 139.19728)')
     expected32 = load_wkt('LINESTRING(-0.2 14.35 100.2, '\
                           '-0.2 11.6 132.8, 1 11.6 128.6)')
     self.assertTrue(a22.almost_equals(expected2d))
     self.assertTrue(a23.almost_equals(expected2d))
     # Do explicit 3D check of coordinate values
     for a, e in zip(a32.coords, expected32.coords):
         for ap, ep in zip(a, e):
             self.assertAlmostEqual(ap, ep)
     for a, e in zip(a33.coords, expected3d.coords):
         for ap, ep in zip(a, e):
             self.assertAlmostEqual(ap, ep)
コード例 #2
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_scale(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test defaults of 1.0
     sls = transform.scale(ls)
     self.assertTrue(sls.equals(ls))
     # different scaling in different dimensions
     sls = transform.scale(ls, 2, 3, 0.5)
     els = load_wkt('LINESTRING(210 500 5, 210 200 15, 330 200 10)')
     self.assertTrue(sls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(sls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # retest with named parameters for the same result
     sls = transform.scale(geom=ls, xfact=2, yfact=3, zfact=0.5,
                           origin='center')
     self.assertTrue(sls.equals(els))
     ## other `origin` parameters
     # around the centroid
     sls = transform.scale(ls, 2, 3, 0.5, origin='centroid')
     els = load_wkt('LINESTRING(228.75 537.5, 228.75 237.5, 348.75 237.5)')
     self.assertTrue(sls.equals(els))
     # around the second coordinate tuple
     sls = transform.scale(ls, 2, 3, 0.5, origin=ls.coords[1])
     els = load_wkt('LINESTRING(240 600, 240 300, 360 300)')
     self.assertTrue(sls.equals(els))
     # around some other 3D Point of origin
     sls = transform.scale(ls, 2, 3, 0.5, origin=Point(100, 200, 1000))
     els = load_wkt('LINESTRING(380 800 505, 380 500 515, 500 500 510)')
     self.assertTrue(sls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(sls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
コード例 #3
0
 def test_scale(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test defaults of 1.0
     sls = affinity.scale(ls)
     self.assertTrue(sls.equals(ls))
     # different scaling in different dimensions
     sls = affinity.scale(ls, 2, 3, 0.5)
     els = load_wkt('LINESTRING(210 500 5, 210 200 15, 330 200 10)')
     self.assertTrue(sls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(sls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # retest with named parameters for the same result
     sls = affinity.scale(geom=ls, xfact=2, yfact=3, zfact=0.5,
                          origin='center')
     self.assertTrue(sls.equals(els))
     ## other `origin` parameters
     # around the centroid
     sls = affinity.scale(ls, 2, 3, 0.5, origin='centroid')
     els = load_wkt('LINESTRING(228.75 537.5, 228.75 237.5, 348.75 237.5)')
     self.assertTrue(sls.equals(els))
     # around the second coordinate tuple
     sls = affinity.scale(ls, 2, 3, 0.5, origin=ls.coords[1])
     els = load_wkt('LINESTRING(240 600, 240 300, 360 300)')
     self.assertTrue(sls.equals(els))
     # around some other 3D Point of origin
     sls = affinity.scale(ls, 2, 3, 0.5, origin=Point(100, 200, 1000))
     els = load_wkt('LINESTRING(380 800 505, 380 500 515, 500 500 510)')
     self.assertTrue(sls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(sls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
コード例 #4
0
ファイル: test_affinity.py プロジェクト: zlavvka/Shapely
 def test_rotate_angle_array(self):
     ls = load_wkt('LINESTRING(240 400, 240 300, 300 300)')
     els = load_wkt('LINESTRING(220 320, 320 320, 320 380)')
     # check with degrees
     theta = numpy.array([90.0])
     rls = affinity.rotate(ls, theta)
     self.assertEqual(theta[0], 90.0)
     self.assertTrue(rls.equals(els))
     # check with radians
     theta = numpy.array([pi / 2])
     rls = affinity.rotate(ls, theta, use_radians=True)
     self.assertEqual(theta[0], pi / 2)
     self.assertTrue(rls.equals(els))
コード例 #5
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_affine_2d(self):
     g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     # custom scale and translate
     expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
     matrix2d = (2, 0, 0, 2.5, -5, 4.1)
     a2 = transform.affine(g, matrix2d)
     self.assertTrue(a2.almost_equals(expected2d))
     self.assertFalse(a2.has_z)
     # Make sure a 3D matrix does not make a 3D shape from a 2D input
     matrix3d = (2, 0, 0, 0, 2.5, 0, 0, 0, 10, -5, 4.1, 100)
     a3 = transform.affine(g, matrix3d)
     self.assertTrue(a3.almost_equals(expected2d))
     self.assertFalse(a3.has_z)
コード例 #6
0
 def __init__(self, wkt, projection):
     if not isinstance(wkt, str):
         raise TypeError("'{}' object is not allowed".format(type(wkt)))
     if not isinstance(projection, str):
         raise TypeError("'{}' object is not allowed".format(type(projection)))
     try:
         load_wkt(wkt)
     except WKTReadingError:
         raise ValueError("The provided geometry is not a valid WKT")
     try:
         utils.get_sr(projection)
     except TypeError:
         raise ValueError("The provided projection is not a valid WKT")
     super().__init__(wkt, projection)
コード例 #7
0
    def test_affine_geom_types(self):

        # identity matrices, which should result with no transformation
        matrix2d = (1, 0,
                    0, 1,
                    0, 0)
        matrix3d = (1, 0, 0,
                    0, 1, 0,
                    0, 0, 1,
                    0, 0, 0)

        # empty in, empty out
        empty2d = load_wkt('MULTIPOLYGON EMPTY')
        self.assertTrue(affinity.affine_transform(empty2d, matrix2d).is_empty)

        def test_geom(g2, g3=None):
            self.assertFalse(g2.has_z)
            a2 = affinity.affine_transform(g2, matrix2d)
            self.assertFalse(a2.has_z)
            self.assertTrue(g2.equals(a2))
            if g3 is not None:
                self.assertTrue(g3.has_z)
                a3 = affinity.affine_transform(g3, matrix3d)
                self.assertTrue(a3.has_z)
                self.assertTrue(g3.equals(a3))
            return

        pt2d = load_wkt('POINT(12.3 45.6)')
        pt3d = load_wkt('POINT(12.3 45.6 7.89)')
        test_geom(pt2d, pt3d)
        ls2d = load_wkt('LINESTRING(0.9 3.4, 0.7 2, 2.5 2.7)')
        ls3d = load_wkt('LINESTRING(0.9 3.4 3.3, 0.7 2 2.3, 2.5 2.7 5.5)')
        test_geom(ls2d, ls3d)
        test_geom(load_wkt('POLYGON((0.9 2.3, 0.5 1.1, 2.4 0.8, 0.9 2.3), '
                           '(1.1 1.7, 0.9 1.3, 1.4 1.2, 1.1 1.7), '
                           '(1.6 1.3, 1.7 1, 1.9 1.1, 1.6 1.3))'))
        test_geom(load_wkt(
            'MULTIPOINT ((-300 300), (700 300), (-800 -1100), (200 -300))'))
        test_geom(load_wkt(
            'MULTILINESTRING((0 0, -0.7 -0.7, 0.6 -1), '
            '(-0.5 0.5, 0.7 0.6, 0 -0.6))'))
        test_geom(load_wkt(
            'MULTIPOLYGON(((900 4300, -1100 -400, 900 -800, 900 4300)), '
            '((1200 4300, 2300 4400, 1900 1000, 1200 4300)))'))
        # GeometryCollection fails, since it does not have a good constructor
        gc = load_wkt('GEOMETRYCOLLECTION(POINT(20 70),'
                      ' POLYGON((60 70, 13 35, 60 -30, 60 70)),'
                      ' LINESTRING(60 70, 50 100, 80 100))')
        self.assertRaises(TypeError, test_geom, gc)  # TODO: fix this
コード例 #8
0
ファイル: test_clip_by_rect.py プロジェクト: zlavvka/Shapely
def polygon_hole_cw_fully_on_rectangle_boundary():
    """Polygon hole (CW) fully on rectangle boundary"""
    geom1 = load_wkt(
        "POLYGON ((0 0, 0 30, 30 30, 30 0, 0 0), (10 10, 10 20, 20 20, 20 10, 10 10))"
    )
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"
コード例 #9
0
def findCenters(newickFile, switchLo, switchHi, lossLo, lossHi):
    """This function takes as input a .newick file in the form 
    <filename>.newick, and low and high values for costscape for both 
    switches and losses. It returns a list of the centroids of each region in 
    the costscape associated with the given .newick file."""

    hostTree, parasiteTree, phi = newickFormatReader(newickFile)
    CVlist = reconcile.reconcile(parasiteTree, hostTree, phi, switchLo,
                                 switchHi, lossLo, lossHi)
    coordList = plotcosts.plotcosts(CVlist, lossLo, lossHi, switchLo,
                                    switchHi, "", False, False)
    polygonList = getNewCoordList(newickFile, switchLo, switchHi, lossLo,
                                  lossHi)
    pointList = []
    for i in range(len(polygonList)):
        point = polygonList[i]
        numCommas = point.count(",")
        if numCommas > 1:
            # polygon case
            region = load_wkt(point)
            pointList.append(region.centroid.wkt)
        elif numCommas == 1:
            # line case
            x1 = coordList[i][0][0]
            y1 = coordList[i][0][1]
            x2 = coordList[i][1][0]
            y2 = coordList[i][1][1]
            midx = (x1 + x2) * 1.0 / 2
            midy = (y1 + y2) * 1.0 / 2
            pointList.append("POINT ({} {})".format(str(midx), str(midy)))
        else:
            # point case
            pointList.append("POINT {}".format(str(coordList[i][0])))

    return pointList
コード例 #10
0
 def process(data, request):
     mode = request["mode"]
     if mode == "time":
         return {"time": [data]}
     elif mode == "meta":
         return {"meta": [None]}
     # load the geometry and transform it into the requested projection
     geometry = load_wkt(data["wkt"])
     if data["projection"] != request["projection"]:
         geometry = utils.shapely_transform(geometry, data["projection"],
                                            request["projection"])
     # take a shortcut when the geometry does not intersect the bbox
     if not geometry.intersects(box(*request["bbox"])):
         return {
             "values":
             np.full((1, request["height"], request["width"]),
                     False,
                     dtype=np.bool),
             "no_data_value":
             None,
         }
     return utils.rasterize_geoseries(
         geoseries=GeoSeries([geometry]) if not geometry.is_empty else None,
         bbox=request["bbox"],
         projection=request["projection"],
         height=request["height"],
         width=request["width"],
     )
コード例 #11
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_translate(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test default offset of 0.0
     tls = transform.translate(ls)
     self.assertTrue(tls.equals(ls))
     # test all offsets
     tls = transform.translate(ls, 100, 400, -10)
     els = load_wkt('LINESTRING(340 800 0, 340 700 20, 400 700 10)')
     self.assertTrue(tls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # retest with named parameters for the same result
     tls = transform.translate(geom=ls, xoff=100, yoff=400, zoff=-10)
     self.assertTrue(tls.equals(els))
コード例 #12
0
ファイル: vectors.py プロジェクト: DigitalGlobe/gbdxtools
    def create_from_wkt(self, wkt, item_type, ingest_source, **attributes):
        '''
        Create a single vector in the vector service

        Args:
            wkt (str): wkt representation of the geometry
            item_type (str): item_type of the vector
            ingest_source (str): source of the vector
            attributes: a set of key-value pairs of attributes

        Returns:
            id (str): string identifier of the vector created
        '''
        # verify the "depth" of the attributes is single layer

        geojson = load_wkt(wkt).__geo_interface__
        vector = {
            'type': "Feature",
            'geometry': geojson,
            'properties': {
                'item_type': item_type,
                'ingest_source': ingest_source,
                'attributes': attributes
            }
        }

        return self.create(vector)[0]
コード例 #13
0
def standardize_polygons_str(data_str):
    """Given a POLYGON string, standardize the coordinates to a 1x1 grid.

    Input : data_str (taken from above)
    Output: tuple of polygon objects
    """
    # find all of the polygons in the letter (for instance an A
    # needs to be constructed from 2 polygons)
    path_strs = re.findall("\(\(([^\)]+?)\)\)", data_str.strip())

    # convert the data into a numpy array
    polygons_data = []
    for path_str in path_strs:
        data = np.array([
            tuple(map(float, x.split())) for x in path_str.strip().split(",")])
        polygons_data.append(data)

    # standardize the coordinates
    min_coords = np.vstack(data.min(0) for data in polygons_data).min(0)
    max_coords = np.vstack(data.max(0) for data in polygons_data).max(0)
    for data in polygons_data:
        data[:, ] -= min_coords
        data[:, ] /= (max_coords - min_coords)

    polygons = []
    for data in polygons_data:
        polygons.append(load_wkt(
            "POLYGON((%s))" % ",".join(" ".join(map(str, x)) for x in data)))

    return tuple(polygons)
コード例 #14
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_translate(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test default offset of 0.0
     tls = transform.translate(ls)
     self.assertTrue(tls.equals(ls))
     # test all offsets
     tls = transform.translate(ls, 100, 400, -10)
     els = load_wkt('LINESTRING(340 800 0, 340 700 20, 400 700 10)')
     self.assertTrue(tls.equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # retest with named parameters for the same result
     tls = transform.translate(geom=ls, xoff=100, yoff=400, zoff=-10)
     self.assertTrue(tls.equals(els))
コード例 #15
0
    def test_seed_with_res_list(self):
        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
        geom = load_wkt(
            "POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")

        self.grid = TileGrid(
            SRS(4326),
            bbox=[-180, -90, 180, 90],
            res=[360 / 256, 360 / 720, 360 / 2000, 360 / 5000, 360 / 8000],
        )
        self.tile_mgr = TileManager(self.grid,
                                    MockCache(), [self.source],
                                    "png",
                                    locker=DummyLocker())
        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
        seeder.walk()

        assert len(self.seed_pool.seeded_tiles) == 5
        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
        assert self.grid.grid_sizes[1] == (3, 2)
        assert self.seed_pool.seeded_tiles[1] == set([(1, 0), (1, 1), (2, 0),
                                                      (2, 1)])
        assert self.grid.grid_sizes[2] == (8, 4)
        assert self.seed_pool.seeded_tiles[2] == set([(4, 2), (5, 2), (4, 3),
                                                      (5, 3), (3, 3)])
        assert self.grid.grid_sizes[3] == (20, 10)
        assert len(self.seed_pool.seeded_tiles[3]) == 5 * 5 + 2
コード例 #16
0
def test_from_polygon_without_enough_tolerance():
    poly = load_wkt('POLYGON ((0 0, 0.5 0, 0.5 0.5, 0 0.5, 0 0))')
    with pytest.raises(ValueError) as exc:
        voronoi_diagram(poly, tolerance=0.6)

    assert "Could not create Voronoi Diagram with the specified inputs" in str(exc.value)
    assert "Try running again with default tolerance value." in str(exc.value)
コード例 #17
0
    def process(data, request):
        mode = request["mode"]
        if mode == "time":
            return {"time": [data]}
        elif mode == "meta":
            return {"meta": [None]}
        # load the geometry and transform it into the requested projection
        geometry = load_wkt(data["wkt"])
        if data["projection"] != request["projection"]:
            geometry = utils.shapely_transform(
                geometry, data["projection"], request["projection"]
            )

        # take a shortcut when the geometry does not intersect the bbox
        x1, y1, x2, y2 = request["bbox"]
        if (x1 == x2) and (y1 == y2):
            # Don't do box(x1, y1, x2, y2), this gives an invalid geometry.
            bbox_geom = Point(x1, y1)
        else:
            bbox_geom = box(x1, y1, x2, y2)
        if not geometry.intersects(bbox_geom):
            return {
                "values": np.full(
                    (1, request["height"], request["width"]), False, dtype=bool
                ),
                "no_data_value": None,
            }

        return utils.rasterize_geoseries(
            geoseries=GeoSeries([geometry]) if not geometry.is_empty else None,
            bbox=request["bbox"],
            projection=request["projection"],
            height=request["height"],
            width=request["width"],
        )
コード例 #18
0
def test_from_polygon_without_floating_point_coordinates():
    poly = load_wkt('POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))')
    with pytest.raises(ValueError) as exc:
        voronoi_diagram(poly, tolerance=0.1)

    assert "Could not create Voronoi Diagram with the specified inputs" in str(exc.value)
    assert "Try running again with default tolerance value." in str(exc.value)
コード例 #19
0
    def create_from_wkt(self, wkt, item_type, ingest_source, **attributes):
        '''
        Create a single vector in the vector service

        Args:
            wkt (str): wkt representation of the geometry
            item_type (str): item_type of the vector
            ingest_source (str): source of the vector
            attributes: a set of key-value pairs of attributes

        Returns:
            id (str): string identifier of the vector created
        '''
        # verify the "depth" of the attributes is single layer

        geojson = load_wkt(wkt).__geo_interface__
        vector = {
            'type': "Feature",
            'geometry': geojson,
            'properties': {
                'item_type': item_type,
                'ingest_source': ingest_source,
                'attributes': attributes
            }
        }

        return self.create(vector)[0]
コード例 #20
0
def build_geometry(Entity):
    """Builds a geometry given an instance."""
    try:
        geometry = load_wkt(Entity.geometry)
    except:
        geometry = box(0, 0, Entity.maxx, Entity.maxy)
    return geometry
コード例 #21
0
    def test_seed_with_res_list(self):
        if not load_wkt: raise SkipTest('no shapely installed')
        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
        geom = load_wkt(
            "POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")

        self.grid = TileGrid(
            SRS(4326),
            bbox=[-180, -90, 180, 90],
            res=[360 / 256, 360 / 720, 360 / 2000, 360 / 5000, 360 / 8000])
        self.tile_mgr = TileManager(self.grid,
                                    MockCache(), [self.source],
                                    'png',
                                    locker=DummyLocker())
        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
        seeder.walk()

        eq_(len(self.seed_pool.seeded_tiles), 5)
        eq_(self.seed_pool.seeded_tiles[0], set([(0, 0)]))
        eq_(self.grid.grid_sizes[1], (3, 2))
        eq_(self.seed_pool.seeded_tiles[1],
            set([(1, 0), (1, 1), (2, 0), (2, 1)]))
        eq_(self.grid.grid_sizes[2], (8, 4))
        eq_(self.seed_pool.seeded_tiles[2],
            set([(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]))
        eq_(self.grid.grid_sizes[3], (20, 10))
        eq_(len(self.seed_pool.seeded_tiles[3]), 5 * 5 + 2)
コード例 #22
0
def test_smaller_envelope():
    mp = MultiPoint(points=[(0.5, 0.5), (1.0, 1.0)])
    poly = load_wkt('POLYGON ((0 0, 0.5 0, 0.5 0.5, 0 0.5, 0 0))')

    regions = voronoi_diagram(mp, envelope=poly)

    assert len(regions.geoms) == 2
    assert sum(r.area for r in regions.geoms) > poly.area
コード例 #23
0
ファイル: test_affinity.py プロジェクト: zlavvka/Shapely
 def test_skew_xs_ys_array(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     els = load_wkt('LINESTRING (253.39745962155615 417.3205080756888, '
                    '226.60254037844385 317.3205080756888, '
                    '286.60254037844385 282.67949192431126)')
     # check with degrees
     xs_ys = numpy.array([15.0, -30.0])
     sls = affinity.skew(ls, xs_ys[0:1], xs_ys[1:2])
     self.assertEqual(xs_ys[0], 15.0)
     self.assertEqual(xs_ys[1], -30.0)
     self.assertTrue(sls.almost_equals(els))
     # check with radians
     xs_ys = numpy.array([pi / 12, -pi / 6])
     sls = affinity.skew(ls, xs_ys[0:1], xs_ys[1:2], use_radians=True)
     self.assertEqual(xs_ys[0], pi / 12)
     self.assertEqual(xs_ys[1], -pi / 6)
     self.assertTrue(sls.almost_equals(els))
コード例 #24
0
 def _load_geometry(self, wkb_or_wkt):
     try:
         return load_wkb(wkb_or_wkt)
     except:
         try:
             return load_wkt(wkb_or_wkt)
         except:
             return None
コード例 #25
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_affine_params(self):
     g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     self.assertRaises(TypeError, transform.affine, g, None)
     self.assertRaises(TypeError, transform.affine, g, '123456')
     self.assertRaises(ValueError, transform.affine, g,
                       [1, 2, 3, 4, 5, 6, 7, 8, 9])
     self.assertRaises(AttributeError, transform.affine, None,
                       [1, 2, 3, 4, 5, 6])
コード例 #26
0
def test_from_multipoint_with_tolerace_without_floating_point_coordinates():
    """This multipoint will not work with a tolerance value."""
    mp = load_wkt('MULTIPOINT (0 0, 1 0, 1 2, 0 1)')
    with pytest.raises(ValueError) as exc:
        voronoi_diagram(mp, tolerance=0.1)

    assert "Could not create Voronoi Diagram with the specified inputs" in str(exc.value)
    assert "Try running again with default tolerance value." in str(exc.value)
コード例 #27
0
ファイル: test_clip_by_rect.py プロジェクト: zlavvka/Shapely
def polygon_overlapping_rectangle():
    """Polygon overlapping rectangle"""
    wkt = "POLYGON ((0 0, 0 30, 30 30, 30 0, 0 0), (10 10, 20 10, 20 20, 10 20, 10 10))"
    geom1 = load_wkt(wkt)
    geom2 = clip_by_rect(geom1, 5, 5, 15, 15)
    assert dump_wkt(
        geom2, rounding_precision=0
    ) == "POLYGON ((5 5, 5 15, 10 15, 10 10, 15 10, 15 5, 5 5))"
コード例 #28
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_scalerotatetranslate(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test defaults
     tls = transform.translate(ls)
     self.assertTrue(tls.equals(ls))
     # test all three
     tls = transform.scalerotatetranslate(ls, 2, 3, 0.5, 30, 100, 400, -10)
     els = load_wkt('LINESTRING(243.03847577293368 849.9038105676659 -5, '\
                    '393.0384757729336200 590.0961894323343100 5, '\
                    '496.9615242270662600 650.0961894323343100 0)')
     self.assertTrue(tls.almost_equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # recheck with named parameters
     tls = transform.scalerotatetranslate(geom=ls,
                                          xfact=2,
                                          yfact=3,
                                          zfact=0.5,
                                          angle=30,
                                          xoff=100,
                                          yoff=400,
                                          zoff=-10,
                                          origin='center',
                                          use_radians=False)
     self.assertTrue(tls.almost_equals(els))
     # test scale and rotate in radians
     tls = transform.scalerotatetranslate(ls,
                                          2,
                                          3,
                                          0.5,
                                          pi / 6,
                                          use_radians=True)
     els = load_wkt('LINESTRING(143.03847577293368 449.90381056766591, '\
                    '293.0384757729336200 190.0961894323343100, '\
                    '396.9615242270662600 250.0961894323343100)')
     self.assertTrue(tls.almost_equals(els))
     # test offsets only
     tls = transform.scalerotatetranslate(ls, xoff=100, yoff=400, zoff=-10)
     els = load_wkt('LINESTRING(340 800, 340 700, 400 700)')
     self.assertTrue(tls.almost_equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
コード例 #29
0
 def __init__ (self, geometry, unique_id, dateRange = 10, completionDate = date.today()):
     # default is search for the past 10 days data
     self.email = '*****@*****.**'
     self.password = '******'
     self.startDate = completionDate - timedelta(days=dateRange)
     self.completionDate = completionDate
     self.geometry = geometry
     self.centroid = load_wkt(geometry).centroid
     self.unique_id = unique_id
コード例 #30
0
def test_from_multipoint_without_floating_point_coordinates():
    """A Multipoint with the same "shape" as the above Polygon raises the same error..."""
    mp = load_wkt('MULTIPOINT (0 0, 1 0, 1 1, 0 1)')

    with pytest.raises(ValueError) as exc:
        voronoi_diagram(mp, tolerance=0.1)

    assert "Could not create Voronoi Diagram with the specified inputs" in str(exc.value)
    assert "Try running again with default tolerance value." in str(exc.value)
コード例 #31
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_affine_2d(self):
     g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     # custom scale and translate
     expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
     matrix2d = (2, 0,
                 0, 2.5,
                 -5, 4.1)
     a2 = transform.affine(g, matrix2d)
     self.assertTrue(a2.almost_equals(expected2d))
     self.assertFalse(a2.has_z)
     # Make sure a 3D matrix does not make a 3D shape from a 2D input
     matrix3d = (2, 0, 0,
                 0, 2.5, 0,
                 0, 0, 10,
                 -5, 4.1, 100)
     a3 = transform.affine(g, matrix3d)
     self.assertTrue(a3.almost_equals(expected2d))
     self.assertFalse(a3.has_z)
コード例 #32
0
ファイル: test_affinity.py プロジェクト: Bmcalpine/Shapely
 def test_affine_params(self):
     g = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     self.assertRaises(
         TypeError, affinity.affine_transform, g, None)
     self.assertRaises(
         TypeError, affinity.affine_transform, g, '123456')
     self.assertRaises(ValueError, affinity.affine_transform, g,
                       [1, 2, 3, 4, 5, 6, 7, 8, 9])
     self.assertRaises(AttributeError, affinity.affine_transform, None,
                       [1, 2, 3, 4, 5, 6])
コード例 #33
0
 def _deserialize(self, value, att, obj):
     try:
         geometry = load_wkt(value)
         return mapping(geometry)
     except WKTReadingError as e:
         try:
             raise ValidationError(e.message)
         # python3 hack for error message handling
         except AttributeError:
             raise ValidationError(str(e))
コード例 #34
0
    def _load_geometry(self, geometry_spec):
        if isinstance(geometry_spec, BaseGeometry):
            return geometry_spec

        try:
            return load_wkb(geometry_spec)
        except:
            try:
                return load_wkt(geometry_spec)
            except:
                return None
コード例 #35
0
    def _load_geometry(self, geometry_spec):
        if isinstance(geometry_spec, BaseGeometry):
            return geometry_spec

        try:
            return load_wkb(geometry_spec)
        except:
            try:
                return load_wkt(geometry_spec)
            except:
                return None
コード例 #36
0
def test_larger_envelope():
    """When the envelope we specify is larger than the
    area of the input feature, the created regions should
    expand to fill that area."""
    mp = MultiPoint(points=[(0.5, 0.5), (1.0, 1.0)])
    poly = load_wkt('POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))')

    regions = voronoi_diagram(mp, envelope=poly)

    assert len(regions.geoms) == 2
    assert sum(r.area for r in regions.geoms) == poly.area
コード例 #37
0
    def calculate_centroid(self):
        centroid = None
        for geometry in self.geometries:
            if geometry.role == GeometryRole.Boundary and geometry.crs == CRS.WGS84:
                p1 = load_wkt(geometry.to_wkt(with_crs=False))
                centroid = Geometry(
                    p1.centroid.wkt.strip("POINT (").strip(")"),
                    GeometryType.Point, GeometryRole.Centroid,
                    "WGS84 Centroid", CRS.WGS84)
                self.geometries.append(centroid)

        return centroid
コード例 #38
0
def return_locations_in_polygon():
    data = request.json
    vehicleData = []
    with open(fileName) as f:
        vehiclesSelect = json.loads(f.read())
    polygon = load_wkt(data['shape'])
    for i in range(0, len(vehiclesSelect)):
        p = Point(vehiclesSelect[i].get('location').get('lng'),
                  vehiclesSelect[i].get('location').get('lat'))
        if polygon.contains(p):
            vehicleData.append(vehiclesSelect[i])
    return jsonify(vehicleData)
コード例 #39
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_rotate(self):
     ls = load_wkt('LINESTRING(240 400, 240 300, 300 300)')
     # counter-clockwise degrees
     rls = transform.rotate(ls, 90)
     els = load_wkt('LINESTRING(220 320, 320 320, 320 380)')
     self.assertTrue(rls.equals(els))
     # retest with named parameters for the same result
     rls = transform.rotate(geom=ls, angle=90, origin='center')
     self.assertTrue(rls.equals(els))
     # clockwise radians
     rls = transform.rotate(ls, -pi/2, use_radians=True)
     els = load_wkt('LINESTRING(320 380, 220 380, 220 320)')
     self.assertTrue(rls.equals(els))
     ## other `origin` parameters
     # around the centroid
     rls = transform.rotate(ls, 90, origin='centroid')
     els = load_wkt('LINESTRING(182.5 320, 282.5 320, 282.5 380)')
     self.assertTrue(rls.equals(els))
     # around the second coordinate tuple
     rls = transform.rotate(ls, 90, origin=ls.coords[1])
     els = load_wkt('LINESTRING(140 300, 240 300, 240 360)')
     self.assertTrue(rls.equals(els))
     # around the absolute Point of origin
     rls = transform.rotate(ls, 90, origin=Point(0,0))
     els = load_wkt('LINESTRING(-400 240, -300 240, -300 300)')
     self.assertTrue(rls.equals(els))
コード例 #40
0
ファイル: test_seed.py プロジェクト: Anderson0026/mapproxy
    def test_seed_with_geom(self):
        if not load_wkt: raise SkipTest('no shapely installed')
        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
        geom = load_wkt("POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")
        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
        seeder.walk()

        eq_(len(self.seed_pool.seeded_tiles), 5)
        eq_(self.seed_pool.seeded_tiles[0], set([(0, 0)]))
        eq_(self.seed_pool.seeded_tiles[1], set([(0, 0), (1, 0)]))
        eq_(self.seed_pool.seeded_tiles[2], set([(1, 1), (2, 1)]))
        eq_(self.seed_pool.seeded_tiles[3], set([(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]))
        eq_(len(self.seed_pool.seeded_tiles[4]), 4*4+2)
コード例 #41
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_scalerotatetranslate(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test defaults
     tls = transform.translate(ls)
     self.assertTrue(tls.equals(ls))
     # test all three
     tls = transform.scalerotatetranslate(ls, 2, 3, 0.5, 30,
                                          100, 400, -10)
     els = load_wkt('LINESTRING(243.03847577293368 849.9038105676659 -5, '\
                    '393.0384757729336200 590.0961894323343100 5, '\
                    '496.9615242270662600 650.0961894323343100 0)')
     self.assertTrue(tls.almost_equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
     # recheck with named parameters
     tls = transform.scalerotatetranslate(geom=ls, xfact=2, yfact=3,
                                          zfact=0.5, angle=30,
                                          xoff=100, yoff=400, zoff=-10,
                                          origin='center', use_radians=False)
     self.assertTrue(tls.almost_equals(els))
     # test scale and rotate in radians
     tls = transform.scalerotatetranslate(ls, 2, 3, 0.5, pi/6,
                                          use_radians=True)
     els = load_wkt('LINESTRING(143.03847577293368 449.90381056766591, '\
                    '293.0384757729336200 190.0961894323343100, '\
                    '396.9615242270662600 250.0961894323343100)')
     self.assertTrue(tls.almost_equals(els))
     # test offsets only
     tls = transform.scalerotatetranslate(ls, xoff=100, yoff=400, zoff=-10)
     els = load_wkt('LINESTRING(340 800, 340 700, 400 700)')
     self.assertTrue(tls.almost_equals(els))
     # Do explicit 3D check of coordinate values
     for a, b in zip(tls.coords, els.coords):
         for ap, bp in zip(a, b):
             self.assertEqual(ap, bp)
コード例 #42
0
ファイル: encoder.py プロジェクト: ptpt/mapbox-vector-tile
    def _load_geometry(self, geometry_spec):
        if isinstance(geometry_spec, BaseGeometry):
            return geometry_spec

        if isinstance(geometry_spec, dict):
            return SimpleShape(geometry_spec['coordinates'],
                               geometry_spec["type"])

        try:
            return load_wkb(geometry_spec)
        except Exception:
            try:
                return load_wkt(geometry_spec)
            except Exception:
                return None
コード例 #43
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_affine_3d(self):
     g2 = load_wkt('LINESTRING(2.4 4.1, 2.4 3, 3 3)')
     g3 = load_wkt('LINESTRING(2.4 4.1 100.2, 2.4 3 132.8, 3 3 128.6)')
     # custom scale and translate
     matrix2d = (2, 0,
                 0, 2.5,
                 -5, 4.1)
     matrix3d = (2, 0, 0,
                 0, 2.5, 0,
                 0, 0, 0.3048,
                 -5, 4.1, 100)
     # Combinations of 2D and 3D geometries and matrices
     a22 = transform.affine(g2, matrix2d)
     a23 = transform.affine(g2, matrix3d)
     a32 = transform.affine(g3, matrix2d)
     a33 = transform.affine(g3, matrix3d)
     # Check dimensions
     self.assertFalse(a22.has_z)
     self.assertFalse(a23.has_z)
     self.assertTrue(a32.has_z)
     self.assertTrue(a33.has_z)
     # 2D equality checks
     expected2d = load_wkt('LINESTRING(-0.2 14.35, -0.2 11.6, 1 11.6)')
     expected3d = load_wkt('LINESTRING(-0.2 14.35 130.54096, '\
                           '-0.2 11.6 140.47744, 1 11.6 139.19728)')
     expected32 = load_wkt('LINESTRING(-0.2 14.35 100.2, '\
                           '-0.2 11.6 132.8, 1 11.6 128.6)')
     self.assertTrue(a22.almost_equals(expected2d))
     self.assertTrue(a23.almost_equals(expected2d))
     # Do explicit 3D check of coordinate values
     for a, e in zip(a32.coords, expected32.coords):
         for ap, ep in zip(a, e):
             self.assertAlmostEqual(ap, ep)
     for a, e in zip(a33.coords, expected3d.coords):
         for ap, ep in zip(a, e):
             self.assertAlmostEqual(ap, ep)
コード例 #44
0
ファイル: test_transform.py プロジェクト: tarsh/shapely
 def test_skew(self):
     ls = load_wkt('LINESTRING(240 400 10, 240 300 30, 300 300 20)')
     # test default shear angles of 0.0
     sls = transform.skew(ls)
     self.assertTrue(sls.equals(ls))
     # different shearing in x- and y-directions
     sls = transform.skew(ls, 15, -30)
     els = load_wkt('LINESTRING (253.39745962155615 417.3205080756888, '\
                    '226.60254037844385 317.3205080756888, '\
                    '286.60254037844385 282.67949192431126)')
     self.assertTrue(sls.almost_equals(els))
     # retest with radians for the same result
     sls = transform.skew(ls, pi/12, -pi/6, use_radians=True)
     self.assertTrue(sls.almost_equals(els))
     # retest with named parameters for the same result
     sls = transform.skew(geom=ls, xs=15, ys=-30,
                          origin='center', use_radians=False)
     self.assertTrue(sls.almost_equals(els))
     ## other `origin` parameters
     # around the centroid
     sls = transform.skew(ls, 15, -30, origin='centroid')
     els = load_wkt('LINESTRING(258.42150697963973 406.49519052838332, '\
                    '231.6265877365273980 306.4951905283833185, '\
                    '291.6265877365274264 271.8541743770057337)')
     self.assertTrue(sls.almost_equals(els))
     # around the second coordinate tuple
     sls = transform.skew(ls, 15, -30, origin=ls.coords[1])
     els = load_wkt('LINESTRING(266.7949192431123038 400, 240 300, '\
                    '300 265.3589838486224153)')
     self.assertTrue(sls.almost_equals(els))
     # around the absolute Point of origin
     sls = transform.skew(ls, 15, -30, origin=Point(0,0))
     els = load_wkt('LINESTRING(347.179676972449101 261.435935394489832, '\
                    '320.3847577293367976 161.4359353944898317, '\
                    '380.3847577293367976 126.7949192431122754)')
     self.assertTrue(sls.almost_equals(els))
コード例 #45
0
    def _loadGeometry(self, geometrySpec):
        """
        A private method to convert a (E)WKB or (E)WKT to a Shapely geometry.
        """
        if type(geometrySpec) is str and geometrySpec.startswith('POLYGON Z'):
            try:
                geometry = load_wkt(geometrySpec)
            except Exception:
                geometry = None
        else:
            try:
                geometry = load_wkb(geometrySpec)
            except Exception:
                geometry = None

        if geometry is None:
            raise ValueError('Failed to convert WKT or WKB to a Shapely geometry')

        return geometry
コード例 #46
0
ファイル: test_seed.py プロジェクト: Anderson0026/mapproxy
    def test_seed_with_res_list(self):
        if not load_wkt: raise SkipTest('no shapely installed')
        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
        geom = load_wkt("POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")

        self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90],
                             res=[360/256, 360/720, 360/2000, 360/5000, 360/8000])
        self.tile_mgr = TileManager(self.grid, MockCache(), [self.source], 'png')
        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
        seeder.walk()

        eq_(len(self.seed_pool.seeded_tiles), 5)
        eq_(self.seed_pool.seeded_tiles[0], set([(0, 0)]))
        eq_(self.grid.grid_sizes[1], (3, 2))
        eq_(self.seed_pool.seeded_tiles[1], set([(1, 0), (1, 1), (2, 0), (2, 1)]))
        eq_(self.grid.grid_sizes[2], (8, 4))
        eq_(self.seed_pool.seeded_tiles[2], set([(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]))
        eq_(self.grid.grid_sizes[3], (20, 10))
        eq_(len(self.seed_pool.seeded_tiles[3]), 5*5+2)
コード例 #47
0
ファイル: vectors.py プロジェクト: DigitalGlobe/gbdxtools
    def aggregate_query(self, searchAreaWkt, agg_def, query=None, start_date=None, end_date=None, count=10, index=default_index):
        """Aggregates results of a query into buckets defined by the 'agg_def' parameter.  The aggregations are
        represented by dicts containing a 'name' key and a 'terms' key holding a list of the aggregation buckets.
        Each bucket element is a dict containing a 'term' key containing the term used for this bucket, a 'count' key
        containing the count of items that match this bucket, and an 'aggregations' key containing any child
        aggregations.

        Args:
            searchAreaWkt (str): wkt representation of the geometry
            agg_def (str or AggregationDef): the aggregation definitions
            query (str): a valid Elasticsearch query string to constrain the items going into the aggregation
            start_date (str): either an ISO-8601 date string or a 'now' expression (e.g. "now-6d" or just "now")
            end_date (str): either an ISO-8601 date string or a 'now' expression (e.g. "now-6d" or just "now")
            count (int): the number of buckets to include in the aggregations (the top N will be returned)
            index (str): the index (or alias or wildcard index expression) to run aggregations against, set to None for the entire set of vector indexes

        Returns:
            results (list): A (usually single-element) list of dict objects containing the aggregation results.
        """

        geojson = load_wkt(searchAreaWkt).__geo_interface__
        aggs_str = str(agg_def) # could be string or AggregationDef

        params = {
            "count": count,
            "aggs": aggs_str
        }

        if query:
            params['query'] = query
        if start_date:
            params['start_date'] = start_date
        if end_date:
            params['end_date'] = end_date

        url = self.aggregations_by_index_url % index if index else self.aggregations_url

        r = self.gbdx_connection.post(url, params=params, json=geojson)
        r.raise_for_status()

        return r.json(object_pairs_hook=OrderedDict)['aggregations']
コード例 #48
0
def test_polygon_shell_cc_fully_on_rectangle_boundary():
    """Polygon shell (CW) fully on rectangle boundary"""
    geom1 = load_wkt("POLYGON ((10 10, 10 20, 20 20, 20 10, 10 10))")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "POLYGON ((10 10, 20 10, 20 20, 10 20, 10 10))"
コード例 #49
0
def polygon_fully_within_rectangle():
    """Polygon fully within rectangle"""
    wkt = "POLYGON ((1 1, 1 30, 30 30, 30 1, 1 1), (10 10, 20 10, 20 20, 10 20, 10 10))"
    geom1 = load_wkt(wkt)
    geom2 = clip_by_rect(geom1, 0, 0, 40, 40)
    assert dump_wkt(geom2, rounding_precision=0) == wkt
コード例 #50
0
def test_point_outside():
    """Point outside"""
    geom1 = load_wkt("POINT (0 0)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"
コード例 #51
0
def test_line_splitting_rectangle():
    """Line splitting rectangle"""
    geom1 = load_wkt("LINESTRING (10 5, 25 20)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "LINESTRING (15 10, 20 15)"
コード例 #52
0
def test_line_on_boundary():
    """Line on boundary"""
    geom1 = load_wkt("LINESTRING (10 15, 10 10, 15 10)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"
コード例 #53
0
ファイル: skew.py プロジェクト: Toblerity/Shapely
from shapely import affinity
from descartes.patch import PolygonPatch

from figures import SIZE, BLUE, GRAY, set_limits, add_origin

fig = pyplot.figure(1, figsize=SIZE, dpi=90)

# Geometry from JTS TestBuilder with fixed precision model of 100.0
# Using CreateShape > FontGlyphSanSerif and A = triangle.wkt from scale.py
R = load_wkt(
    """\
POLYGON((2.218 2.204, 2.273 2.18, 2.328 2.144, 2.435 2.042, 2.541 1.895,
  2.647 1.702, 3 1, 2.626 1, 2.298 1.659, 2.235 1.777, 2.173 1.873,
  2.112 1.948, 2.051 2.001, 1.986 2.038, 1.91 2.064, 1.823 2.08, 1.726 2.085,
  1.347 2.085, 1.347 1, 1 1, 1 3.567, 1.784 3.567, 1.99 3.556, 2.168 3.521,
  2.319 3.464, 2.441 3.383, 2.492 3.334, 2.536 3.279, 2.604 3.152,
  2.644 3.002, 2.658 2.828, 2.651 2.712, 2.63 2.606, 2.594 2.51, 2.545 2.425,
  2.482 2.352, 2.407 2.29, 2.319 2.241, 2.218 2.204),
 (1.347 3.282, 1.347 2.371, 1.784 2.371, 1.902 2.378, 2.004 2.4, 2.091 2.436,
  2.163 2.487, 2.219 2.552, 2.259 2.63, 2.283 2.722, 2.291 2.828, 2.283 2.933,
  2.259 3.025, 2.219 3.103, 2.163 3.167, 2.091 3.217, 2.004 3.253, 1.902 3.275,
  1.784 3.282, 1.347 3.282))"""
)

# 1
ax = fig.add_subplot(121)

patch1a = PolygonPatch(R, facecolor=GRAY, edgecolor=GRAY, alpha=0.5, zorder=1)
skewR = affinity.skew(R, xs=20, origin=(1, 1))
patch1b = PolygonPatch(skewR, facecolor=BLUE, edgecolor=BLUE, alpha=0.5, zorder=2)
ax.add_patch(patch1a)
ax.add_patch(patch1b)
コード例 #54
0
def test_line_inside():
    """Line inside"""
    geom1 = load_wkt("LINESTRING (15 15, 16 15)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "LINESTRING (15 15, 16 15)"
コード例 #55
0
def test_line_outside():
    """Line outside"""
    geom1 = load_wkt("LINESTRING (0 0, -5 5)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"
コード例 #56
0
def polygon_hole_cw_fully_on_rectangle_boundary():
    """Polygon hole (CW) fully on rectangle boundary"""
    geom1 = load_wkt("POLYGON ((0 0, 0 30, 30 30, 30 0, 0 0), (10 10, 10 20, 20 20, 20 10, 10 10))")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"
コード例 #57
0
def test_point_inside():
    """Point inside"""
    geom1 = load_wkt("POINT (15 15)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "POINT (15 15)"
コード例 #58
0
def test_point_on_boundary():
    """Point on boundary"""
    geom1 = load_wkt("POINT (15 10)")
    geom2 = clip_by_rect(geom1, 10, 10, 20, 20)
    assert dump_wkt(geom2, rounding_precision=0) == "GEOMETRYCOLLECTION EMPTY"