Python GeoSeries.representative_point方法代码示例

# 需要导入模块: from geopandas import GeoSeries [as 别名]
# 或者: from geopandas.GeoSeries import representative_point [as 别名]

#.........这里部分代码省略.........

    def test_difference_poly(self):
        u = self.g1.difference(self.t2)
        self.assertTrue(u[0].equals(self.t1))
        self.assertTrue(u[1].equals(self.t1))

    def test_is_valid(self):
        self.assertTrue(np.alltrue(self.g1.is_valid))

    def test_is_empty(self):
        self.assertTrue(np.alltrue(np.logical_not(self.g1.is_empty)))

    def test_is_ring(self):
        self.assertTrue(np.alltrue(self.g1.is_ring))

    def test_is_simple(self):
        self.assertTrue(np.alltrue(self.g1.is_simple))

    def test_envelope(self):
        e = self.g3.envelope
        self.assertTrue(np.alltrue(e.equals(self.sq)))
        self.assertIsInstance(e, GeoSeries)
        self.assertEqual(self.g3.crs, e.crs)

    @unittest.skip('TODO')
    def test_exterior(self):
        # TODO
        pass

    @unittest.skip('TODO')
    def test_interiors(self):
        # TODO
        pass

    def test_representative_point(self):
        self.assertTrue(np.alltrue(self.g1.contains(self.g1.representative_point())))
        self.assertTrue(np.alltrue(self.g2.contains(self.g2.representative_point())))
        self.assertTrue(np.alltrue(self.g3.contains(self.g3.representative_point())))
        self.assertTrue(np.alltrue(self.g4.contains(self.g4.representative_point())))

    def test_transform(self):
        utm18n = self.landmarks.to_crs(epsg=26918)
        lonlat = utm18n.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.landmarks.almost_equals(lonlat)))
        with self.assertRaises(ValueError):
            self.g1.to_crs(epsg=4326)
        with self.assertRaises(TypeError):
            self.landmarks.to_crs(crs=None, epsg=None)

    def test_fillna(self):
        na = self.na_none.fillna()
        self.assertTrue(isinstance(na[2], BaseGeometry))
        self.assertTrue(na[2].is_empty)
        with self.assertRaises(NotImplementedError):
            self.na_none.fillna(method='backfill')
        
    def test_interpolate(self):
        res = self.g5.interpolate(0.75, normalized=True)
        self.assertTrue(geom_equals(res, GeoSeries([Point(0.5, 1.0),
                                                    Point(0.75, 1.0)])))
        res = self.g5.interpolate(1.5)
        self.assertTrue(geom_equals(res, GeoSeries([Point(0.5, 1.0),
                                                    Point(1.0, 0.5)])))
        
    def test_project(self):
        res = self.g5.project(Point(1.0, 0.5))
        assert_array_equal(res, [2.0, 1.5])
        res = self.g5.project(Point(1.0, 0.5), normalized=True)
        assert_array_equal(res, [1.0, 0.5])
        
    def test_translate_tuple(self):
        trans = self.sol.x - self.esb.x, self.sol.y - self.esb.y
        self.assertTrue(self.landmarks.translate(*trans)[0].equals(self.sol))
    
    def test_rotate(self):
        angle = 98
        res = self.g4.rotate(angle, origin=Point(0,0))
        self.assertTrue(geom_almost_equals(self.g4, res.rotate(-angle, 
            origin=Point(0,0))))

    def test_scale(self):
        scale = 2., 1.
        inv = tuple(1./i for i in scale)
        res = self.g4.scale(*scale, origin=Point(0,0))
        self.assertTrue(geom_almost_equals(self.g4, res.scale(*inv, 
            origin=Point(0,0))))
        
    def test_skew(self):
        skew = 45.
        res = self.g4.skew(xs=skew, origin=Point(0,0))
        self.assertTrue(geom_almost_equals(self.g4, res.skew(xs=-skew, 
            origin=Point(0,0))))
        res = self.g4.skew(ys=skew, origin=Point(0,0))
        self.assertTrue(geom_almost_equals(self.g4, res.skew(ys=-skew, 
            origin=Point(0,0))))
            
    def test_total_bounds(self):
        bbox = self.sol.x, self.sol.y, self.esb.x, self.esb.y
        self.assertEqual(self.landmarks.total_bounds, bbox)
        self.assertEqual(self.g1.total_bounds, (0, 0, 1, 1))

# 需要导入模块: from geopandas import GeoSeries [as 别名]
# 或者: from geopandas.GeoSeries import representative_point [as 别名]

#.........这里部分代码省略.........
        self.l2 = LineString([(0, 0), (1, 0), (1, 1), (0, 1)])
        self.g5 = GeoSeries([self.l1, self.l2])

    def tearDown(self):
        shutil.rmtree(self.tempdir)

    def test_single_geom_constructor(self):
        p = Point(1,2)
        line = LineString([(2, 3), (4, 5), (5, 6)])
        poly = Polygon([(0, 0), (1, 0), (1, 1)],
                          [[(.1, .1), (.9, .1), (.9, .9)]])
        mp = MultiPoint([(1, 2), (3, 4), (5, 6)])
        mline = MultiLineString([[(1, 2), (3, 4), (5, 6)], [(7, 8), (9, 10)]])

        poly2 = Polygon([(1, 1), (1, -1), (-1, -1), (-1, 1)],
                        [[(.5, .5), (.5, -.5), (-.5, -.5), (-.5, .5)]])
        mpoly = MultiPolygon([poly, poly2])

        geoms = [p, line, poly, mp, mline, mpoly]
        index = ['a', 'b', 'c', 'd']

        for g in geoms:
            gs = GeoSeries(g)
            self.assert_(len(gs) == 1)
            self.assert_(gs.iloc[0] is g)

            gs = GeoSeries(g, index=index)
            self.assert_(len(gs) == len(index))
            for x in gs:
                self.assert_(x is g)

    def test_copy(self):
        gc = self.g3.copy()
        self.assertTrue(type(gc) is GeoSeries)
        self.assertEqual(self.g3.name, gc.name)
        self.assertEqual(self.g3.crs, gc.crs)

    def test_in(self):
        self.assertTrue(self.t1 in self.g1)
        self.assertTrue(self.sq in self.g1)
        self.assertTrue(self.t1 in self.a1)
        self.assertTrue(self.t2 in self.g3)
        self.assertTrue(self.sq not in self.g3)
        self.assertTrue(5 not in self.g3)

    def test_geom_equals(self):
        self.assertTrue(np.alltrue(self.g1.geom_equals(self.g1)))
        assert_array_equal(self.g1.geom_equals(self.sq), [False, True])

    def test_geom_equals_align(self):
        a = self.a1.geom_equals(self.a2)
        self.assertFalse(a['A'])
        self.assertTrue(a['B'])
        self.assertFalse(a['C'])

    def test_align(self):
        a1, a2 = self.a1.align(self.a2)
        self.assertTrue(a2['A'].is_empty)
        self.assertTrue(a1['B'].equals(a2['B']))
        self.assertTrue(a1['C'].is_empty)

    def test_geom_almost_equals(self):
        # TODO: test decimal parameter
        self.assertTrue(np.alltrue(self.g1.geom_almost_equals(self.g1)))
        assert_array_equal(self.g1.geom_almost_equals(self.sq), [False, True])

    def test_geom_equals_exact(self):
        # TODO: test tolerance parameter
        self.assertTrue(np.alltrue(self.g1.geom_equals_exact(self.g1, 0.001)))
        assert_array_equal(self.g1.geom_equals_exact(self.sq, 0.001), [False, True])

    def test_to_file(self):
        """ Test to_file and from_file """
        tempfilename = os.path.join(self.tempdir, 'test.shp')
        self.g3.to_file(tempfilename)
        # Read layer back in?
        s = GeoSeries.from_file(tempfilename)
        self.assertTrue(all(self.g3.geom_equals(s)))
        # TODO: compare crs

    def test_representative_point(self):
        self.assertTrue(np.alltrue(self.g1.contains(self.g1.representative_point())))
        self.assertTrue(np.alltrue(self.g2.contains(self.g2.representative_point())))
        self.assertTrue(np.alltrue(self.g3.contains(self.g3.representative_point())))
        self.assertTrue(np.alltrue(self.g4.contains(self.g4.representative_point())))

    def test_transform(self):
        utm18n = self.landmarks.to_crs(epsg=26918)
        lonlat = utm18n.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.landmarks.geom_almost_equals(lonlat)))
        with self.assertRaises(ValueError):
            self.g1.to_crs(epsg=4326)
        with self.assertRaises(TypeError):
            self.landmarks.to_crs(crs=None, epsg=None)

    def test_fillna(self):
        na = self.na_none.fillna(Point())
        self.assertTrue(isinstance(na[2], BaseGeometry))
        self.assertTrue(na[2].is_empty)
        self.assertTrue(geom_equals(self.na_none[:2], na[:2]))

# 需要导入模块: from geopandas import GeoSeries [as 别名]
# 或者: from geopandas.GeoSeries import representative_point [as 别名]

#.........这里部分代码省略.........
        self.assertTrue(5 not in self.g3)

    def test_geom_equals(self):
        self.assertTrue(np.alltrue(self.g1.geom_equals(self.g1)))
        assert_array_equal(self.g1.geom_equals(self.sq), [False, True])

    def test_geom_equals_align(self):
        a = self.a1.geom_equals(self.a2)
        self.assertFalse(a['A'])
        self.assertTrue(a['B'])
        self.assertFalse(a['C'])

    def test_align(self):
        a1, a2 = self.a1.align(self.a2)
        self.assertTrue(a2['A'].is_empty)
        self.assertTrue(a1['B'].equals(a2['B']))
        self.assertTrue(a1['C'].is_empty)

    def test_geom_almost_equals(self):
        # TODO: test decimal parameter
        self.assertTrue(np.alltrue(self.g1.geom_almost_equals(self.g1)))
        assert_array_equal(self.g1.geom_almost_equals(self.sq), [False, True])

    def test_geom_equals_exact(self):
        # TODO: test tolerance parameter
        self.assertTrue(np.alltrue(self.g1.geom_equals_exact(self.g1, 0.001)))
        assert_array_equal(self.g1.geom_equals_exact(self.sq, 0.001), [False, True])

    def test_to_file(self):
        """ Test to_file and from_file """
        tempfilename = os.path.join(self.tempdir, 'test.shp')
        self.g3.to_file(tempfilename)
        # Read layer back in?
        s = GeoSeries.from_file(tempfilename)
        self.assertTrue(all(self.g3.geom_equals(s)))
        # TODO: compare crs

    def test_to_json(self):
        """Test whether GeoSeries.to_json works and returns an actual json file."""
        json_str = self.g3.to_json()
        json_dict = json.loads(json_str)
        # TODO : verify the output is a valid GeoJSON.

    def test_representative_point(self):
        self.assertTrue(np.alltrue(self.g1.contains(self.g1.representative_point())))
        self.assertTrue(np.alltrue(self.g2.contains(self.g2.representative_point())))
        self.assertTrue(np.alltrue(self.g3.contains(self.g3.representative_point())))
        self.assertTrue(np.alltrue(self.g4.contains(self.g4.representative_point())))

    def test_transform(self):
        utm18n = self.landmarks.to_crs(epsg=26918)
        lonlat = utm18n.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.landmarks.geom_almost_equals(lonlat)))
        with self.assertRaises(ValueError):
            self.g1.to_crs(epsg=4326)
        with self.assertRaises(TypeError):
            self.landmarks.to_crs(crs=None, epsg=None)

    def test_fillna(self):
        na = self.na_none.fillna(Point())
        self.assertTrue(isinstance(na[2], BaseGeometry))
        self.assertTrue(na[2].is_empty)
        self.assertTrue(geom_equals(self.na_none[:2], na[:2]))
        # XXX: method works inconsistently for different pandas versions
        #self.na_none.fillna(method='backfill')

    def test_coord_slice(self):
        """ Test CoordinateSlicer """
        # need some better test cases
        self.assertTrue(geom_equals(self.g3, self.g3.cx[:, :]))
        self.assertTrue(geom_equals(self.g3[[True, False]], self.g3.cx[0.9:, :0.1]))
        self.assertTrue(geom_equals(self.g3[[False, True]], self.g3.cx[0:0.1, 0.9:1.0]))

    def test_geoseries_geointerface(self):
        self.assertEqual(self.g1.__geo_interface__['type'], 'FeatureCollection')
        self.assertEqual(len(self.g1.__geo_interface__['features']),
                         self.g1.shape[0])

    def test_proj4strings(self):
        # As string
        reprojected = self.g3.to_crs('+proj=utm +zone=30N')
        reprojected_back = reprojected.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.g3.geom_almost_equals(reprojected_back)))

        # As dict
        reprojected = self.g3.to_crs({'proj': 'utm', 'zone': '30N'})
        reprojected_back = reprojected.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.g3.geom_almost_equals(reprojected_back)))

        # Set to equivalent string, convert, compare to original
        copy = self.g3.copy()
        copy.crs = '+init=epsg:4326'
        reprojected = copy.to_crs({'proj': 'utm', 'zone': '30N'})
        reprojected_back = reprojected.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.g3.geom_almost_equals(reprojected_back)))

        # Conversions by different format
        reprojected_string = self.g3.to_crs('+proj=utm +zone=30N')
        reprojected_dict = self.g3.to_crs({'proj': 'utm', 'zone': '30N'})
        self.assertTrue(np.alltrue(reprojected_string.geom_almost_equals(reprojected_dict)))

# 需要导入模块: from geopandas import GeoSeries [as 别名]
# 或者: from geopandas.GeoSeries import representative_point [as 别名]

#.........这里部分代码省略.........
        assert a1['B'].equals(a2['B'])
        assert a1['C'].is_empty

    def test_almost_equals(self):
        assert np.alltrue(self.g1.equals(self.g1))
        assert np.all(self.g1.equals(self.sq).values == np.array([0, 1], dtype=bool))

    def test_equals_exact(self):
        assert np.alltrue(self.g1.equals(self.g1))
        assert np.all(self.g1.equals(self.sq).values == np.array([0, 1], dtype=bool))

    def test_crosses(self):
        # TODO
        pass

    def test_disjoint(self):
        # TODO
        pass

    def test_intersects(self):
        # TODO
        pass

    def test_overlaps(self):
        # TODO
        pass

    def test_touches(self):
        # TODO
        pass

    def test_within(self):
        # TODO
        pass

    def test_intersection(self):
        assert geom_equals(self.g1 & self.g2, self.t1)

    def test_union_series(self):
        u = self.g1.union(self.g2)
        assert u[0].equals(self.sq)
        assert u[1].equals(self.sq)
        assert geom_equals(u, self.g1 | self.g2)

    def test_union_polgon(self):
        u = self.g1.union(self.t2)
        assert u[0].equals(self.sq)
        assert u[1].equals(self.sq)

    def test_symmetric_difference_series(self):
        u = self.g3.symmetric_difference(self.g4)
        assert u[0].equals(self.sq)
        assert u[1].equals(self.sq)
        assert geom_equals(u, self.g3 ^ self.g4)

    def test_symmetric_difference_poly(self):
        u = self.g3.symmetric_difference(self.t1)
        assert u[0].is_empty
        assert u[1].equals(self.sq)

    def test_difference_series(self):
        u = self.g1.difference(self.g2)
        assert u[0].is_empty
        assert u[1].equals(self.t2)
        assert geom_equals(u, self.g1 - self.g2)

    def test_difference_poly(self):
        u = self.g1.difference(self.t2)
        assert u[0].equals(self.t1)
        assert u[1].equals(self.t1)

    def test_is_valid(self):
        assert np.alltrue(self.g1.is_valid)

    def test_is_empty(self):
        assert np.alltrue(np.logical_not(self.g1.is_empty))

    def test_is_ring(self):
        assert np.alltrue(self.g1.is_ring)

    def test_is_simple(self):
        assert np.alltrue(self.g1.is_simple)

    def test_envelope(self):
        e = self.g3.envelope
        assert np.alltrue(e.equals(self.sq))

    def test_exterior(self):
        # TODO
        pass

    def test_interiors(self):
        # TODO
        pass

    def test_representative_point(self):
        assert np.alltrue(self.g1.contains(self.g1.representative_point()))
        assert np.alltrue(self.g2.contains(self.g2.representative_point()))
        assert np.alltrue(self.g3.contains(self.g3.representative_point()))
        assert np.alltrue(self.g4.contains(self.g4.representative_point()))

# 需要导入模块: from geopandas import GeoSeries [as 别名]
# 或者: from geopandas.GeoSeries import representative_point [as 别名]

#.........这里部分代码省略.........

    def test_disjoint(self):
        # TODO
        pass

    def test_intersects(self):
        # TODO
        pass

    def test_overlaps(self):
        # TODO
        pass

    def test_touches(self):
        # TODO
        pass

    def test_within(self):
        # TODO
        pass

    def test_intersection(self):
        self.assertTrue(geom_equals(self.g1 & self.g2, self.t1))

    def test_union_series(self):
        u = self.g1.union(self.g2)
        self.assertTrue(u[0].equals(self.sq))
        self.assertTrue(u[1].equals(self.sq))
        self.assertTrue(geom_equals(u, self.g1 | self.g2))

    def test_union_polgon(self):
        u = self.g1.union(self.t2)
        self.assertTrue(u[0].equals(self.sq))
        self.assertTrue(u[1].equals(self.sq))

    def test_symmetric_difference_series(self):
        u = self.g3.symmetric_difference(self.g4)
        self.assertTrue(u[0].equals(self.sq))
        self.assertTrue(u[1].equals(self.sq))
        self.assertTrue(geom_equals(u, self.g3 ^ self.g4))
        self.assertEqual(self.g3.crs, u.crs)

    def test_symmetric_difference_poly(self):
        u = self.g3.symmetric_difference(self.t1)
        self.assertTrue(u[0].is_empty)
        self.assertTrue(u[1].equals(self.sq))
        self.assertEqual(self.g3.crs, u.crs)

    def test_difference_series(self):
        u = self.g1.difference(self.g2)
        self.assertTrue(u[0].is_empty)
        self.assertTrue(u[1].equals(self.t2))
        self.assertTrue(geom_equals(u, self.g1 - self.g2))

    def test_difference_poly(self):
        u = self.g1.difference(self.t2)
        self.assertTrue(u[0].equals(self.t1))
        self.assertTrue(u[1].equals(self.t1))

    def test_is_valid(self):
        self.assertTrue(np.alltrue(self.g1.is_valid))

    def test_is_empty(self):
        self.assertTrue(np.alltrue(np.logical_not(self.g1.is_empty)))

    def test_is_ring(self):
        self.assertTrue(np.alltrue(self.g1.is_ring))

    def test_is_simple(self):
        self.assertTrue(np.alltrue(self.g1.is_simple))

    def test_envelope(self):
        e = self.g3.envelope
        self.assertTrue(np.alltrue(e.equals(self.sq)))
        self.assertIsInstance(e, GeoSeries)
        self.assertEqual(self.g3.crs, e.crs)

    def test_exterior(self):
        # TODO
        pass

    def test_interiors(self):
        # TODO
        pass

    def test_representative_point(self):
        self.assertTrue(np.alltrue(self.g1.contains(self.g1.representative_point())))
        self.assertTrue(np.alltrue(self.g2.contains(self.g2.representative_point())))
        self.assertTrue(np.alltrue(self.g3.contains(self.g3.representative_point())))
        self.assertTrue(np.alltrue(self.g4.contains(self.g4.representative_point())))

    def test_transform(self):
        utm18n = self.landmarks.to_crs(epsg=26918)
        lonlat = utm18n.to_crs(epsg=4326)
        self.assertTrue(np.alltrue(self.landmarks.almost_equals(lonlat)))

    def test_fillna(self):
        na = self.na_none.fillna()
        self.assertTrue(isinstance(na[2], BaseGeometry))
        self.assertTrue(na[2].is_empty)