示例#1
0
def test_from_epsg():
    proj = CRS.from_epsg(4326)
    assert proj.to_epsg() == 4326

    # Test with invalid EPSG code
    with pytest.raises(CRSError):
        assert CRS.from_epsg(0)
示例#2
0
def test_sub_crs():
    crs = CRS.from_epsg(5972)
    sub_crs_list = crs.sub_crs_list
    assert len(sub_crs_list) == 2
    assert sub_crs_list[0] == CRS.from_epsg(25832)
    assert sub_crs_list[1] == CRS.from_epsg(5941)
    assert crs.is_projected
    assert not crs.is_geographic
示例#3
0
def test_coordinate_system():
    crs = CRS.from_epsg(26915)
    assert repr(crs.coordinate_system).startswith("CS[Cartesian")
    assert crs.coordinate_system.name == "cartesian"
    assert crs.coordinate_system.name == str(crs.coordinate_system)
    assert crs.coordinate_system.axis_list == crs.axis_info
    assert len(crs.coordinate_system.axis_list) == 2
示例#4
0
def test_datum():
    datum = CRS.from_epsg(4326).datum
    assert repr(datum).startswith('DATUM["World Geodetic System 1984"')
    assert "\n" in repr(datum)
    assert datum.to_wkt().startswith('DATUM["World Geodetic System 1984"')
    assert datum == datum
    assert datum.is_exact_same(datum)
示例#5
0
def test_coordinate_operation():
    crs = CRS.from_epsg(26915)
    assert repr(crs.coordinate_operation).startswith('CONVERSION["UTM zone 15N"')
    assert crs.coordinate_operation.method_name == "Transverse Mercator"
    assert crs.coordinate_operation.name == str(crs.coordinate_operation)
    assert crs.coordinate_operation.method_auth_name == "EPSG"
    assert crs.coordinate_operation.method_code == "9807"
    assert crs.coordinate_operation.is_instantiable == 1
    assert crs.coordinate_operation.has_ballpark_transformation == 0
    assert crs.coordinate_operation.accuracy == -1.0
    assert repr(crs.coordinate_operation.params) == (
        "[Param(name=Latitude of natural origin, auth_name=EPSG, code=8801, "
        "value=0.0, unit_name=degree, unit_auth_name=EPSG, "
        "unit_code=9102, unit_category=angular), "
        "Param(name=Longitude of natural origin, auth_name=EPSG, code=8802, "
        "value=-93.0, unit_name=degree, unit_auth_name=EPSG, "
        "unit_code=9102, unit_category=angular), "
        "Param(name=Scale factor at natural origin, auth_name=EPSG, code=8805, "
        "value=0.9996, unit_name=unity, unit_auth_name=EPSG, "
        "unit_code=9201, unit_category=scale), "
        "Param(name=False easting, auth_name=EPSG, code=8806, value=500000.0, "
        "unit_name=metre, unit_auth_name=EPSG, unit_code=9001, unit_category=linear), "
        "Param(name=False northing, auth_name=EPSG, code=8807, value=0.0, "
        "unit_name=metre, unit_auth_name=EPSG, unit_code=9001, unit_category=linear)]"
    )
    assert crs.coordinate_operation.grids == []
示例#6
0
    def test_georef_with_depth_nan(self):
        multibeam = self.dset.raw_ping[0].isel(time=0).expand_dims('time')
        dpth_with_nan = expected_depth.copy()
        dpth_with_nan[0][10] = np.nan
        dpth_with_nan[0][20] = np.nan

        x = xr.DataArray(data=expected_alongtrack, dims=['time', 'beam'], coords={'time': multibeam.time.values,
                                                                                  'beam': multibeam.beam.values})
        y = xr.DataArray(data=expected_acrosstrack, dims=['time', 'beam'], coords={'time': multibeam.time.values,
                                                                                   'beam': multibeam.beam.values})
        z = xr.DataArray(data=dpth_with_nan, dims=['time', 'beam'], coords={'time': multibeam.time.values,
                                                                            'beam': multibeam.beam.values})
        sv_corr = [x, y, z]

        raw_attitude = self.dset.raw_att
        heading = raw_attitude.heading.interp_like(z)
        heave = raw_attitude.heave.interp_like(z)

        altitude = self.dset.raw_ping[0].altitude
        longitude = self.dset.raw_ping[0].longitude
        latitude = self.dset.raw_ping[0].latitude

        installation_params_time = list(self.dset.xyzrph['tx_r'].keys())[0]
        waterline = float(self.dset.xyzrph['waterline'][installation_params_time])
        vert_ref = 'waterline'

        input_datum = CRS.from_epsg(7911)
        output_datum = CRS.from_epsg(26910)

        z_offset = 1.0

        georef_x, georef_y, georef_z, corrected_heave, corrected_altitude, vdatumunc, geohashes = georef_by_worker(
            sv_corr, altitude,
            longitude, latitude,
            heading, heave,
            waterline, vert_ref,
            input_datum,
            output_datum,
            z_offset)
        assert np.array_equal(georef_x, expected_georef_x)
        assert np.array_equal(georef_y, expected_georef_y)
        assert np.isnan(georef_z.values[0][10])
        assert np.isnan(georef_z.values[0][20])
示例#7
0
def test_area_epsg4326():
    """Test with EPSG4326 (latlong) area, which has no CRS coordinate operation."""
    from pyproj import CRS
    shp = (16, 8)
    euro4326 = create_area_def("epgs4326europa",
                               CRS.from_epsg(4326),
                               resolution=1 / 128,
                               shape=shp,
                               center=(0, 0))
    return euro4326
示例#8
0
 def from_wsf(cls, wsf):
     """
     parse wsf:srs uri i.e http://www.opengis.net/gml/srs/epsg.xml#4326. From wsf:uri is strip epsg code that is
     entered into from_epsg function. Side effect, accept also EPSG as str
     :param wsf: str - wsf:uri
     :return pyproj.CRS
     """
     loc = wsf.find('#')
     epsg = wsf[loc + 1:]
     return CRS.from_epsg(epsg)
示例#9
0
def test_custom_tms_bounds_user_crs():
    """Check bounds with epsg4326."""
    custom_tms = TileMatrixSet.custom(
        (-120, 30, -110, 40),
        CRS.from_epsg(4326),
    )
    assert custom_tms.xy_bbox == (-120, 30, -110, 40)
    assert custom_tms.bbox == (-120, 30, -110, 40)
    assert custom_tms.xy_bounds(0, 0, 0) == (-120, 30, -110, 40)
    assert custom_tms.bounds(0, 0, 0) == (-120, 30, -110, 40)
示例#10
0
def test_creating_multiple_crs_without_file_limit():
    """
    This test checks for two things:
    1. Ensure database connection is closed for file limit
       https://github.com/pyproj4/pyproj/issues/374
    2. Ensure core-dumping does not occur when many objects are created
       https://github.com/pyproj4/pyproj/issues/678
    """
    codes = get_codes("EPSG", PJType.PROJECTED_CRS, False)
    assert [CRS.from_epsg(code) for code in codes]
示例#11
0
    def clip_to_bbox(self, bbox, bbox_crs):
        msg = f"bbox must be a {Bbox} instance."
        assert isinstance(bbox, Bbox), msg
        bbox_pol = Polygon(
                [[bbox.xmin, bbox.ymin],
                 [bbox.xmax, bbox.ymin],
                 [bbox.xmax, bbox.ymax],
                 [bbox.xmin, bbox.ymax],
                 [bbox.xmin, bbox.ymin]
                 ])
        _switch = True
        unique_dates = np.unique(self._df['datetime'])
        _found_start_date = False
        for _datetime in unique_dates:
            records = self._df[self._df['datetime'] == _datetime]
            radii = records['radius_of_last_closed_isobar'].iloc[0]
            radii = 1852. * radii  # convert to meters
            lon = records['longitude'].iloc[0]
            lat = records['latitude'].iloc[0]
            _, _, number, letter = utm.from_latlon(lat, lon)
            df_crs = CRS.from_epsg(4326)
            utm_crs = CRS(
                    proj='utm',
                    zone=f'{number}{letter}',
                    ellps={
                        'GRS 1980': 'GRS80',
                        'WGS 84': 'WGS84'
                        }[df_crs.ellipsoid.name]
                )
            transformer = Transformer.from_crs(
                df_crs, utm_crs, always_xy=True)
            p = Point(*transformer.transform(lon, lat))
            pol = p.buffer(radii)
            transformer = Transformer.from_crs(
                utm_crs, bbox_crs, always_xy=True)
            pol = ops.transform(transformer.transform, pol)
            if _switch is True:
                if not pol.intersects(bbox_pol):
                    continue
                else:
                    self.start_date = records['datetime'].iloc[0]
                    _found_start_date = True
                    _switch = False
                    continue

            else:
                if pol.intersects(bbox_pol):
                    continue
                else:
                    self.end_date = records['datetime'].iloc[0]
                    break

        if _found_start_date is False:
            raise Exception(
                f'No data within mesh bounding box for storm {self.storm_id}.')
示例#12
0
    def __init__(self, fname, grid, crs):

        self.grid = grid
        self.crs = crs

        # grid centroilds
        xc = (np.arange(grid['nx']) + .5) * grid['dx'] + grid['x0']
        yc = (np.arange(grid['ny']) + .5) * grid['dy'] + grid['y0']
        self.x = xc
        self.y = yc

        # crs
        crs_wgs = CRS.from_epsg(4326)
        crs_model = CRS.from_proj4(crs.proj4_init)

        self.trns = Transformer.from_crs(crs_wgs, crs_model)

        # read the receptor file
        df = pd.read_csv(fname, delimiter=' ', names=['rdx', 'lat', 'lon'])

        # get x,y coords
        x, y = [_ * .001 for _ in self.trns.transform(df.lat, df.lon)]
        df['x'], df['y'] = x, y

        # get i,j
        idx = np.array([np.arange(len(xc))[np.isclose(_, xc)][0] for _ in x])
        jdx = np.array([np.arange(len(yc))[np.isclose(_, yc)][0] for _ in y])
        df['idx0'], df['jdx0'] = idx, jdx
        df['idx1'], df['jdx1'] = idx + 1, jdx + 1

        # see if grid is fully covered, and if it does order
        nx, ny = len(self.x), len(self.y)
        self.nx, self.ny = nx, ny
        cnt_g = nx * ny
        cnt_d = len(df.index)
        self.nsta = cnt_d
        if cnt_g == cnt_d:
            # full
            if np.all(idx == np.tile(np.arange(nx), ny)) \
                    and np.all(jdx == np.repeat(np.arange(ny), nx)):
                self.coverage = 'full, c-order'
            elif np.all(idx == np.repeat(np.arange(nx), ny)) \
                and np.all(jdx == np.tile(np.arange(ny), nx)):
                self.coverage = 'full, f-order'
            else:
                self.coverage = 'full, random'
        elif cnt_g > cnt_d:
            self.coverage = 'partial, random'
        else:
            raise ValueError('more data than grid def')

        print(self.coverage)

        #df = df.set_index('rdx', drop=False)
        self.df = df
示例#13
0
    def __init__(self, grid_tuple):
        self.name = grid_tuple.name
        self.epsg = grid_tuple.epsg
        self.rows = grid_tuple.rows
        self.cols = grid_tuple.cols
        self.cell_width = grid_tuple.cell_width
        self.cell_height = grid_tuple.cell_height
        self.upper_left_x = grid_tuple.upper_left_x
        self.upper_left_y = grid_tuple.upper_left_y

        self.crs = CRS.from_epsg(grid_tuple.epsg)
def interpolate_from_latlon(interpolator, interpolator_crs):
    input_crs = CRS.from_epsg(4326)
    transformer = Transformer.from_crs(input_crs,
                                       interpolator_crs,
                                       always_xy=True)

    def interpol(lat, lon):
        r, h = transformer.transform(lon, lat)
        return interpolator(r, h)

    return interpol
示例#15
0
def test_datum():
    datum = CRS.from_epsg(4326).datum
    assert "\n" in repr(datum)
    if PROJ_GTE_8:
        datum_wkt = 'ENSEMBLE["World Geodetic System 1984 ensemble"'
    else:
        datum_wkt = 'DATUM["World Geodetic System 1984"'
    assert repr(datum).startswith(datum_wkt)
    assert datum.to_wkt().startswith(datum_wkt)
    assert datum == datum
    assert datum.is_exact_same(datum)
示例#16
0
def test_coordinate_system_geog():
    crs = CRS.from_epsg(4326)
    assert repr(crs.coordinate_system).startswith("CS[ellipsoidal")
    assert crs.coordinate_system.name == "ellipsoidal"
    assert crs.coordinate_system.name == str(crs.coordinate_system)
    assert crs.coordinate_system.axis_list == crs.axis_info
    assert repr(crs.coordinate_system.axis_list) == (
        "[Axis(name=Geodetic latitude, abbrev=Lat, direction=north, "
        "unit_auth_code=EPSG, unit_code=9122, unit_name=degree), "
        "Axis(name=Geodetic longitude, abbrev=Lon, direction=east, "
        "unit_auth_code=EPSG, unit_code=9122, unit_name=degree)]")
示例#17
0
def infer_crs(crs_str: str) -> Optional[str]:
    plausible_list = [
        PJCRS.from_epsg(code).to_wkt() for code in DEFAULT_CRS_INFERENCES
    ]
    closest_wkt = difflib.get_close_matches(crs_str,
                                            plausible_list,
                                            cutoff=0.38)
    if len(closest_wkt) == 0:
        return
    epsg = PJCRS.from_wkt(closest_wkt[0]).to_epsg()
    return f"epsg:{epsg}"
示例#18
0
 def wgs84_utm_zone(self):
     """
     Finds the UTM zone where the first point of the GCP falls into
     :return utm zone string valid for a coordinates header
     """
     if self.entries_count() > 0:
         entry = self.get_entry(0)
         longlat = CRS.from_epsg("4326")
         lon, lat = location.transform2(self.srs, longlat, entry.x, entry.y)
         utm_zone, hemisphere = location.get_utm_zone_and_hemisphere_from(lon, lat)
         return "WGS84 UTM %s%s" % (utm_zone, hemisphere)
示例#19
0
def test_to_wkt_enum():
    crs = CRS.from_epsg(4326)
    assert crs.to_wkt("WKT1_GDAL") == crs.to_wkt(WktVersion.WKT1_GDAL)
    assert crs.to_wkt("WKT2_2018") == crs.to_wkt(WktVersion.WKT2_2018)
    assert crs.to_wkt("WKT2_2018_SIMPLIFIED") == crs.to_wkt(
        WktVersion.WKT2_2018_SIMPLIFIED
    )
    assert crs.to_wkt("WKT2_2015") == crs.to_wkt(WktVersion.WKT2_2015)
    assert crs.to_wkt("WKT2_2015_SIMPLIFIED") == crs.to_wkt(
        WktVersion.WKT2_2015_SIMPLIFIED
    )
示例#20
0
def validate_crs(ctx, param, value):
    if not value:
        return CRS.from_epsg(4326)
    elif value == "keep":
        return None
    if value.isdigit():
        value = int(value)
    try:
        return CRS.from_user_input(value)
    except pyproj.exceptions.CRSError as e:
        raise click.BadParameter(str(e))
示例#21
0
def build_crs(zone_num: str = None,
              datum: str = None,
              epsg: str = None,
              projected: bool = True):
    horizontal_crs = None
    if epsg:
        try:
            horizontal_crs = CRS.from_epsg(int(epsg))
        except CRSError:  # if the CRS we generate here has no epsg, when we save it to disk we save the proj string
            horizontal_crs = CRS.from_string(epsg)
    elif not epsg and not projected:
        datum = datum.upper()
        if datum == 'NAD83':
            horizontal_crs = CRS.from_epsg(epsg_determinator('nad83(2011)'))
        elif datum == 'WGS84':
            horizontal_crs = CRS.from_epsg(epsg_determinator('wgs84'))
        else:
            err = '{} not supported.  Only supports WGS84 and NAD83'.format(
                datum)
            return horizontal_crs, err
    elif not epsg and projected:
        datum = datum.upper()
        zone = zone_num  # this will be the zone and hemi concatenated, '10N'
        try:
            zone, hemi = int(zone[:-1]), str(zone[-1:])
        except:
            raise ValueError(
                'construct_crs: found invalid projected zone/hemisphere identifier: {}, expected something like "10N"'
                .format(zone))

        if datum == 'NAD83':
            horizontal_crs = CRS.from_epsg(
                epsg_determinator('nad83(2011)', zone=zone, hemisphere=hemi))
        elif datum == 'WGS84':
            horizontal_crs = CRS.from_epsg(
                epsg_determinator('wgs84', zone=zone, hemisphere=hemi))
        else:
            err = '{} not supported.  Only supports WGS84 and NAD83'.format(
                datum)
            return horizontal_crs, err
    return horizontal_crs, ''
示例#22
0
def geodeticToProj(lat, lon, ellip, proj_out, proj_in=6319):
    """Convert geodetic coordinates to projected coordinate system

    Parameters:
        lat (np.array): latitudes
        lon (np.array): longitudes
        ellip (np.height): ellipsoid heights
        proj_out (int): epsg code of output projected coordinate system
        proj_in (int): epsg code of input geodetic coordinate system, defaults to NAD83 (2011)

    Returns:
        tuple: X, Y, Z of projected coordinate system
    """

    # Define transformation parameters
    geodetic = CRS.from_epsg(proj_in)
    projected = CRS.from_epsg(proj_out)
    transformer = Transformer.from_crs(geodetic, projected)

    # Transform coordinates
    return transformer.transform(lat, lon, ellip)
示例#23
0
def test_coordinate_system_geog():
    crs = CRS.from_epsg(4326)
    assert repr(crs.coordinate_system).startswith("CS[ellipsoidal")
    assert crs.coordinate_system.name == "ellipsoidal"
    assert crs.coordinate_system.name == str(crs.coordinate_system)
    assert crs.coordinate_system.axis_list == crs.axis_info
    assert repr(crs.coordinate_system.axis_list) == (
        "[Axis(name=Geodetic latitude, abbrev=Lat, direction=north, "
        "unit_auth_code=EPSG, unit_code=9122, unit_name=degree), "
        "Axis(name=Geodetic longitude, abbrev=Lon, direction=east, "
        "unit_auth_code=EPSG, unit_code=9122, unit_name=degree)]"
    )
示例#24
0
def ll2utm(lat, lon):
    """
    Convert lat/long to UTM coordinates (m)

    :param lat: latitude (decimal)
    :param lon: longitude (decimal)
    :return: x, y, ((utm_zone, north/south, latitude_letter), projection_instance)
    """
    utm_z = get_utm_zone(lat, lon)
    p = Proj(CRS.from_epsg(get_wgs84_utm_epsg_code(*utm_z)))
    x, y = p(lon, lat)
    return x, y, (utm_z, p)
示例#25
0
 def test_geometric_dict(self):
     geometric_object = GeometricClass(Point(-77, 38.9))
     geometric_dict = GeometricDict()
     geometric_dict[123] = geometric_object
     geometric_dict[234] = geometric_object
     crs_4326 = CRS.from_epsg(4326)
     geometric_dict.crs = crs_4326
     geometric_dict.to_geoseries()
     folium_map = folium.Map(location=(38.9, -77), zoom_start=12)
     geometric_dict.plot_folium(folium_map)
     aea = CRS.from_string("North America Albers Equal Area Conic")
     geometric_dict.to_crs(aea)
示例#26
0
def name_to_crs(name, default=None):
    return {
        "latlon": CRS.from_epsg(geo_capnp.EPSG.wgs84),
        "wgs84": CRS.from_epsg(geo_capnp.EPSG.wgs84),
        "gk3": CRS.from_epsg(geo_capnp.EPSG.gk3),
        "gk4": CRS.from_epsg(geo_capnp.EPSG.gk4),
        "gk5": CRS.from_epsg(geo_capnp.EPSG.gk5),
        "utm21s": CRS.from_epsg(geo_capnp.EPSG.utm21S),
        "utm32n": CRS.from_epsg(geo_capnp.EPSG.utm32N)
    }.get(name.lower(), default)
 def meta_update(self, buffer_image, buffer_region, affine):
     # self represent the original file meta data
     meta_data = self.meta.copy()
     epsg_code = int(buffer_region.crs['init'][5:])
     meta_data.update({
         "driver": "GTiff",
         "height": buffer_image.shape[1],
         "width": buffer_image.shape[2],
         "transform": affine,
         "crs": CRS.from_epsg(epsg_code).to_proj4()
     })
     return meta_data
示例#28
0
    def read_nid(self):
        df = pd.read_excel(self.data_config.nid_file)
        """transform data to geopandas"""
        data = gpd.GeoDataFrame(df, crs=CRS.from_epsg(self.data_config.nid_epsg).to_wkt())
        data['geometry'] = None
        for idx in range(df.shape[0]):
            # create a point based on x and y column values on this row:
            point = Point(df['LONGITUDE'][idx], df['LATITUDE'][idx])
            # Add the point object to the geometry column on this row:
            data.at[idx, 'geometry'] = point

        return data
示例#29
0
    def _custom_output_crs(self, destination_epsg: int):
        try:
            out_crs = CRS.from_epsg(int(destination_epsg))
        except CRSError:
            self.log_error(f'Expected integer epsg code that is readable by the pyproj CRS object, got {destination_epsg}',
                           ValueError)
        if out_crs.is_vertical:
            self.log_error(f'Only 2d coordinate system epsg supported when using the new_2d_crs option, got {destination_epsg}',
                           ValueError)
        in_crs = CRS.from_epsg(6319)
        # Transformer.transform input order is based on the CRS, see CRS.geodetic_crs.axis_info
        # - lon, lat - this appears to be valid when using CRS from proj4 string
        # - lat, lon - this appears to be valid when using CRS from epsg
        # use the always_xy option to force the transform to expect lon/lat order
        transformer = Transformer.from_crs(in_crs, out_crs, always_xy=True)
        new_min_x, new_min_y = transformer.transform(self.geographic_min_x, self.geographic_min_y)
        new_max_x, new_max_y = transformer.transform(self.geographic_max_x, self.geographic_max_y)

        # if out_crs.is_projected:
        #     if new_min_x < 0:
        #         new_min_x = int(np.ceil(new_min_x))
        #     else:
        #         new_min_x = int(np.floor(new_min_x))
        #     if new_min_y < 0:
        #         new_min_y = int(np.ceil(new_min_y))
        #     else:
        #         new_min_y = int(np.floor(new_min_y))
        #     if new_max_x < 0:
        #         new_max_x = int(np.floor(new_max_x))
        #     else:
        #         new_max_x = int(np.ceil(new_max_x))
        #     if new_max_y < 0:
        #         new_max_y = int(np.floor(new_max_y))
        #     else:
        #         new_max_y = int(np.ceil(new_max_y))

        x_rez = (new_max_x - new_min_x) / self.width
        y_rez = (new_max_y - new_min_y) / self.height
        self.output_geotransform = (new_min_x, x_rez, 0.0, new_max_y, 0.0, -y_rez)
        self.out_crs.horiz_wkt = out_crs.to_wkt()
def calculate_bounding_box(given_srid):
    """
    calculate the local bounding box and 
    return a shapely polygon of this BB with local coordq
    """
    xmin, ymin, xmax, ymax = CRS.from_epsg(given_srid).area_of_use.bounds
    bounding_polygon_4326 = Polygon([(xmin, ymin), (xmax, ymin), (xmax, ymax),
                                     (xmin, ymax)])

    projection = Transformer.from_crs(CRS(4326),
                                      CRS(int(given_srid)),
                                      always_xy=True)
    return transform(projection.transform, bounding_polygon_4326)
示例#31
0
 def _save_hfun_to_db(self, hfun, id):
     self._logger.debug("_save_hfun_to_db()")
     _original_crs = hfun.crs
     if not _original_crs.equals(CRS.from_epsg(4326)):
         self._logger.debug(f"tranforming from {hfun.crs} to EPSG:4326")
         hfun.transform_to('EPSG:4326')
     self._session.add(
         db.Hfun(
             hfun=geoalchemy2.shape.from_shape(hfun.multipolygon),
             id=id))
     self._session.commit()
     if not hfun.crs.equals(_original_crs):
         hfun.transform_to(_original_crs)
示例#32
0
 def _save_geom_to_db(self, geom, id):
     self._logger.debug("_save_geom_to_db()")
     _original_crs = geom.crs
     if not _original_crs.equals(CRS.from_epsg(4326)):
         self._logger.debug(f"tranforming from {geom.crs} to EPSG:4326")
         geom.transform_to('EPSG:4326')
     self._session.add(
         db.Geom(
             geom=geoalchemy2.shape.from_shape(geom.multipolygon),
             id=id))
     self._session.commit()
     if not geom.crs.equals(_original_crs):
         geom.transform_to(_original_crs)
def NormCoords(lista, NORM):  # Recibe una lista de coordenadas

    from pyproj.aoi import AreaOfInterest
    from pyproj.database import query_utm_crs_info
    from pyproj import CRS
    from pyproj import Proj
    import math
    import numpy as np
    import pandas as pd

    Lat = np.array(lista)[:, 0]
    Long = np.array(lista)[:, 1]

    utm_crs_list = query_utm_crs_info(
        datum_name="WGS 84",
        area_of_interest=AreaOfInterest(
            west_lon_degree=Lat.mean(),
            south_lat_degree=Long.mean(),
            east_lon_degree=Lat.mean(),
            north_lat_degree=Long.mean(),
        ),
    )

    utm_crs = CRS.from_epsg(utm_crs_list[0].code)

    myProj = Proj(utm_crs_list[0].name)

    UTMx, UTMy = myProj(Long, Lat, inverse=False)

    MxLon = UTMx.max()
    MnLon = UTMx.min()
    MxLat = UTMy.max()
    MnLat = UTMy.min()

    bx = (UTMx.max() - UTMx.min())
    by = (UTMy.max() - UTMy.min())

    NormLon = []
    NormLat = []

    for i in range(0, len(UTMx)):

        NormLon.append((UTMx[i] - MxLon) * NORM / bx + NORM)
        NormLat.append((UTMy[i] - MxLat) * NORM / by + NORM)

    Info = []

    for i in range(0, len(NormLon)):
        Info.append([NormLon[i], NormLat[i]])

    return (Info)
    def plot(self, sph_epsg=4326, car_epsg=3857):
        """
        Visualize the grid.If the coordinate system is spherical, it will be automatically
        convert to cartesian coordinate system. You can specify the EPSG of coordiante
        by assigning sph_egsp and car_epsg. Find the EPSG of more coordinate system in
        the following link. https://developers.arcgis.com/javascript/3/jshelp/pcs.htm
        Parameters
        ----------
        sph_epsg : int, optional
        car_epsg : int, optional

        Examples
        -------
        >>> grd = GrdFile('river.grd')
        >>> grd.plot()
        >>> grd.plot(sph_epsg=4326, car_epsg=26917)
        """
        if self.header['Coordinate System'] == 'Spherical':
            # transform from spherical to cartesian
            grd_crs = CRS.from_epsg(sph_epsg)
            plot_crs = CRS.from_epsg(car_epsg)
            projection = Transformer.from_crs(grd_crs, plot_crs)
            x, y = projection.transform(self.x, self.y)
            print(
                "Automatically transform from spherical to cartesian coordinates.\n"
                "Change the default projection by giving specific grd_epsg and plot_epsg"
            )
        else:
            x, y = self.x, self.y
        # plot grid
        plt.pcolormesh(x,
                       y,
                       np.zeros(np.shape(self.x)),
                       edgecolor=None,
                       facecolor='none',
                       linewidth=0.005)
        plt.axis('equal')
        plt.show()
示例#35
0
    def _build_polygons(self, polygon: np.ndarray, geographic: bool):
        """
        Build separate geographic/projected polygon coordinates from the provided polygon coordinates

        Parameters
        ----------
        polygon
            (N, 2) array of points that make up the selection polygon
        geographic
            If True, the coordinates provided are geographic (latitude/longitude)

        Returns
        -------
        polygon
            (N, 2) array of points that make up the selection polygon in geographic coordinates
        polygon
            (N, 2) array of points that make up the selection polygon in projected coordinates in the Fqpr instance coordinate system
        """
        if isinstance(polygon, list):
            polygon = np.array(polygon)

        if not geographic:
            proj_polygon = polygon
            trans = Transformer.from_crs(
                CRS.from_epsg(self.fqpr.multibeam.raw_ping[0].horizontal_crs),
                CRS.from_epsg(kluster_variables.epsg_wgs84),
                always_xy=True)
            polyx, polyy = trans.transform(polygon[:, 0], polygon[:, 1])
            geo_polygon = np.c_[polyx, polyy]
        else:
            geo_polygon = polygon
            trans = Transformer.from_crs(
                CRS.from_epsg(kluster_variables.epsg_wgs84),
                CRS.from_epsg(self.fqpr.multibeam.raw_ping[0].horizontal_crs),
                always_xy=True)
            polyx, polyy = trans.transform(polygon[:, 0], polygon[:, 1])
            proj_polygon = np.c_[polyx, polyy]
        return geo_polygon, proj_polygon
示例#36
0
    def set_crs(self,
                crs=None,
                epsg=None,
                inplace=False,
                allow_override=False):
        """
        Set the Coordinate Reference System (CRS) of a ``GeoSeries``.

        NOTE: The underlying geometries are not transformed to this CRS. To
        transform the geometries to a new CRS, use the ``to_crs`` method.

        Parameters
        ----------
        crs : pyproj.CRS, optional if `epsg` is specified
            The value can be anything accepted
            by :meth:`pyproj.CRS.from_user_input() <pyproj.crs.CRS.from_user_input>`,
            such as an authority string (eg "EPSG:4326") or a WKT string.
        epsg : int, optional if `crs` is specified
            EPSG code specifying the projection.
        inplace : bool, default False
            If True, the CRS of the GeoSeries will be changed in place
            (while still returning the result) instead of making a copy of
            the GeoSeries.
        allow_override : bool, default False
            If the the GeoSeries already has a CRS, allow to replace the
            existing CRS, even when both are not equal.

        Returns
        -------
        GeoSeries
        """
        if crs is not None:
            crs = CRS.from_user_input(crs)
        elif epsg is not None:
            crs = CRS.from_epsg(epsg)
        else:
            raise ValueError("Must pass either crs or epsg.")

        if not allow_override and self.crs is not None and not self.crs == crs:
            raise ValueError(
                "The GeoSeries already has a CRS which is not equal to the passed "
                "CRS. Specify 'allow_override=True' to allow replacing the existing "
                "CRS without doing any transformation. If you actually want to "
                "transform the geometries, use 'GeoSeries.to_crs' instead.")
        if not inplace:
            result = self.copy()
        else:
            result = self
        result.crs = crs
        return result
示例#37
0
def test_to_wkt_pretty():
    crs = CRS.from_epsg(4326)
    assert "\n" in crs.to_wkt(pretty=True)
    assert "\n" not in crs.to_wkt()
示例#38
0
def test_epsg():
    assert CRS({"init": "EPSG:4326"}).to_epsg(20) == 4326
    assert CRS({"init": "EPSG:4326"}).to_epsg() is None
    assert CRS.from_user_input(4326).to_epsg() == 4326
    assert CRS.from_epsg(4326).to_epsg() == 4326
    assert CRS.from_user_input("epsg:4326").to_epsg() == 4326
示例#39
0
def test_datum_horizontal():
    assert CRS.from_epsg(5972).datum == CRS.from_epsg(25832).datum
示例#40
0
def test_coordinate_operation__missing():
    crs = CRS.from_epsg(4326)
    assert crs.coordinate_operation is None
示例#41
0
def test_sub_crs__none():
    assert CRS.from_epsg(4326).sub_crs_list == []
示例#42
0
def test_ellipsoid():
    crs1 = CRS.from_epsg(4326)
    assert "{:.3f}".format(crs1.ellipsoid.inverse_flattening) == "298.257"
    assert "{:.3f}".format(crs1.ellipsoid.semi_major_metre) == "6378137.000"
    assert "{:.3f}".format(crs1.ellipsoid.semi_minor_metre) == "6356752.314"
示例#43
0
def test_area_of_use():
    crs1 = CRS.from_epsg(4326)
    assert crs1.area_of_use.bounds == (-180.0, -90.0, 180.0, 90.0)
    assert crs1.area_of_use.name == "World"
示例#44
0
 def to_wkt(self):
     return CRS.from_epsg(4326).to_wkt()
示例#45
0
def test_from_user_input_custom_crs_class():
    class CustomCRS(object):
        def to_wkt(self):
            return CRS.from_epsg(4326).to_wkt()

    assert CRS.from_user_input(CustomCRS()) == CRS.from_epsg(4326)