예제 #1
0
     max = featCount * len(inRasters)
 else:
     max = featCount * bands
 pb = progressBar(max + 1, 65)
 i = 0
 start = time.time()
 # process points and rasters
 for f in fileInfos:
     i += 1
     pb.update(i)
     gt = f.geotransform
     rasterCRS = f.projection
     #print "Layer", layerCRS.ExportToWkt()
     #print "Raster", rasterCRS.ExportToWkt()
     if needTransform:
         coordTransform = osr.CoordinateTransformation(layerCRS, rasterCRS)
         if coordTransform is None and needTransform:
             print 'Error while creating coordinate transformation.'
             sys.exit(1)
     if not gdalalloc:
         ds = gdal.Open(f.fileName)
     if f.bands == 1:
         shortName = f.fileBaseName[:10]
         if not gdalalloc:
             band = ds.ReadAsArray()
         inLayer.ResetReading()
         inFeat = inLayer.GetNextFeature()
         while inFeat is not None:
             i += 1
             pb.update(i)
             geom = inFeat.GetGeometryRef()
예제 #2
0
    def as_dataframe(self, **kwargs):
        """
        Creates a dataframe object for a shapefile's main layer using layer_as_dataframe. This object is cached on disk for
        layer use, but the cached copy will only be picked up if the shapefile's mtime is older than the dataframe's mtime.

        :param shp: The shapefile
        :return:
        """

        dfx_path = self.get_filename('dfx')
        if os.path.exists(dfx_path):
            try:
                self._df = pandas.read_pickle(dfx_path)
            except:
                os.unlink(self.get_filename('dfx'))

        if len(kwargs) != 0:
            cfg = self.resource.driver_config
            lyr = {}
            crx = xrc = None

            if 'bbox' in kwargs:
                minx, miny, maxx, maxy = kwargs['bbox']

                if 'srs' in kwargs:
                    if isinstance(kwargs['srs'], basestring):
                        s_srs = osr.SpatialReference()
                        if kwargs['srs'].lower().startswith('epsg:'):
                            s_srs.ImportFromEPSG(
                                int(kwargs['srs'].split(':')[1]))
                        else:
                            s_srs.ImportFromProj4(kwargs['srs'])
                    else:
                        s_srs = kwargs['srs']

                    t_srs = self.resource.srs

                    if s_srs.ExportToProj4() != t_srs.ExportToProj4():
                        crx = osr.CoordinateTransformation(s_srs, t_srs)
                        minx, miny, _ = crx.TransformPoint(minx, miny)
                        maxx, maxy, _ = crx.TransformPoint(maxx, maxy)
                        xrc = osr.CoordinateTransformation(t_srs, s_srs)

                lyr['bbox'] = (minx, miny, maxx, maxy)
            elif 'boundary' in kwargs:
                lyr['boundary'] = kwargs['boundary']

            if 'query' in kwargs:
                lyr['query'] = []

                if isinstance(kwargs['query'], basestring):
                    query = json.loads(kwargs['query'])
                else:
                    query = kwargs['query']

                lyr['query'] = ' AND '.join(
                    self.attrquery(key, value) for key, value in query.items())

            start = kwargs['start'] if 'start' in kwargs else 0
            count = start + kwargs['count'] if 'count' in kwargs else -1

            # contsruct query

            cursor = self.connection  # _cursor(**kwargs)

            q = "SELECT AsBinary({geometry_column}), * FROM ({table}) AS w WHERE "
            addand = False
            if 'bbox' in lyr:
                q += "ST_Intersects(GeomFromText('BBOX({xmin} {ymin} {xax} {ymax})'), {geometry_column})"
                addand = True

            if 'boundary' in lyr:
                q += "ST_Intersects(GeomFromText('{boundary}', {geometry_column}))"
                addand = True

            if 'query' in lyr:
                if addand:
                    q += ' AND '
                q += lyr['query']

            if count > 0:
                q += ' LIMIT {count}'.format(count=count)

            table, geometry_column = self._table(**kwargs)
            if table.strip().lower().startswith('select'):
                table = '(' + table + ")"

            cursor.execute(
                q.format(boundary=cfg.get('boundary', None),
                         geometry_column=geometry_column,
                         table=table,
                         **lyr.get('bbox', [None, None, None, None])))
            for i in range(start):
                cursor.fetchone()

            names = [c[0] for c in cursor.description]
            throwaway_ix = names[1:].index(geometry_column) + 1
            records = []
            for record in cursor:
                records.append({
                    name: value
                    for i, (name, value) in enumerate(zip(names, record))
                    if i != throwaway_ix
                })
                records[-1]['geometry'] = wkb.loads(record['asbinary'])

            df = DataFrame.from_records(data=records, index='fid')

            if 'sort_by' in kwargs:
                df = df.sort_index(by=kwargs['sort_by'])

            return df

        elif hasattr(self, '_df'):
            return self._df

        else:
            table, geometry_column = self._table(**kwargs)

            query = "SELECT AsBinary({geometry_column}), * FROM {table}".format(
                table=table, geometry_column=geometry_column)
            cursor = self._cursor(**kwargs)
            cursor.execute("select load_extension('libspatialite.so')")

            cursor.execute(query)
            names = [c[0] for c in cursor.description]

            throwaway_ix = names[1:].index(geometry_column) + 1
            records = []
            for record in cursor:
                records.append({
                    name: value
                    for i, (name, value) in enumerate(zip(names, record))
                    if i != throwaway_ix
                })
                records[-1]['geometry'] = wkb.loads(
                    str(records[-1]['AsBinary(GEOMETRY)']))
                del records[-1]['AsBinary(GEOMETRY)']

            df = DataFrame.from_records(data=records)
            df.to_pickle(dfx_path)
            self._df = df
            return self._df
def test_overlapping(shp_img, img):

    if shp_img.endswith('.shp'):

        # --------------  IN SHP  -------------------
        #print "Shapefile vs raster <br>"
        shp_ds = ogr.Open(shp_img)
        layer = shp_ds.GetLayer(0)
        INSR = layer.GetSpatialRef()
        INextent = layer.GetExtent()
        shp_ds = None

    if shp_img.endswith('.tif') or shp_img.endswith('.vrt'):

        # --------------  IN IMG  -------------------
        #print "Raster vs raster <br>"
        in_ds = gdal.Open(shp_img)
        INSR = osr.SpatialReference()
        INSR.ImportFromWkt(in_ds.GetProjectionRef())

        geoTransform = in_ds.GetGeoTransform()
        minx = geoTransform[0]
        maxy = geoTransform[3]
        maxx = minx + geoTransform[1] * in_ds.RasterXSize
        miny = maxy + geoTransform[5] * in_ds.RasterYSize
        INextent = [minx, maxx, miny, maxy]
        in_ds = None

    print INextent

    # --------------  IN IMG  -------------------

    img_ds = gdal.Open(img)
    imgGeo = img_ds.GetGeoTransform()

    cols = img_ds.RasterXSize
    rows = img_ds.RasterYSize

    imgSR = osr.SpatialReference()
    imgSR.ImportFromWkt(img_ds.GetProjectionRef())
    img_ds = None
    transform = osr.CoordinateTransformation(imgSR, INSR)
    (ulx, uly, holder) = transform.TransformPoint(imgGeo[0], imgGeo[3])
    (lrx, lry, holder) = transform.TransformPoint(imgGeo[0] + cols * imgGeo[1],
                                                  imgGeo[3] + rows * imgGeo[5])

    wkt1 = "POLYGON ((" + str(INextent[0]) + " " + str(
        INextent[2]) + "," + str(INextent[1]) + " " + str(
            INextent[2]) + "," + str(INextent[1]) + " " + str(
                INextent[3]) + "," + str(INextent[0]) + " " + str(
                    INextent[3]) + "," + str(INextent[0]) + " " + str(
                        INextent[2]) + "))"
    wkt2 = "POLYGON ((" + str(ulx) + " " + str(uly) + "," + str(
        lrx) + " " + str(uly) + "," + str(lrx) + " " + str(lry) + "," + str(
            ulx) + " " + str(lry) + "," + str(ulx) + " " + str(uly) + "))"

    poly1 = ogr.CreateGeometryFromWkt(wkt1)
    poly2 = ogr.CreateGeometryFromWkt(wkt2)

    intersection = poly1.Intersection(poly2)
    #print intersection.ExportToWkt()
    return (intersection.ExportToWkt() != 'GEOMETRYCOLLECTION EMPTY')
예제 #4
0
    # Load conservation attributes first. That's all we need from this ShapeFile
    conserve = os.path.join(
        top_level_folder, region,
        '01_Perennial_Network/03_Conservation_Restoration_Model/Conservation_Restoration_Model_Perennial_{}.shp'
        .format(region.replace('_', '')))
    consatts = load_attributes(conserve, 'ReachID', ['oPBRC_UI', 'oPBRC_CR'])

    # Use the geometries from the capacity ShapeFile for the output
    capacity = os.path.join(
        top_level_folder, region,
        '01_Perennial_Network/02_Combined_Capacity_Model/Combined_Capacity_Model_Perennial_{}.shp'
        .format(region.replace('_', '')))
    inDataSource = driver.Open(capacity, 0)
    inLayer = inDataSource.GetLayer()
    transform = osr.CoordinateTransformation(inLayer.GetSpatialRef(),
                                             outSpatialRef)

    for feature in inLayer:
        reachid = feature.GetField('ReachID')
        geom = feature.GetGeometryRef()
        geom.Transform(transform)

        # Create output Feature
        outFeature = ogr.Feature(outLayerDefn)
        outFeature.SetField('ReachID', reachid)
        outFeature.SetField('oCC_EX', feature.GetField('oCC_EX'))
        outFeature.SetField('oCC_HPE', feature.GetField('oCC_HPE'))
        outFeature.SetField('HUC', feature.GetField('HUC_ID'))
        outFeature.SetField('oPBRC_UI', risks[consatts[reachid]['oPBRC_UI']])
        outFeature.SetField('oPBRC_CR',
                            opportunities[consatts[reachid]['oPBRC_CR']])
예제 #5
0
파일: model.py 프로젝트: moghimis/thyme
    def init_xy_with_subsets(self, lon_min, lat_min, lon_max, lat_max, target_cellsize_meters, subset_grid_shp, subset_grid_field_name=None):
        """Create & initialize x/y dimensions/coordinate vars and subset vars.

        Args:
            lon_min: Minimum longitude of domain.
            lat_min: Minimum latitude of domain.
            lon_max: Maximum longitude of domain.
            lat_max: Maximum latitude of domain.
            target_cellsize_meters: Target cell size, in meters. Actual
                calculated cell sizes will be approximations of this.
            subset_grid_shp: Path to subset grid polygon shapefile used to
                define subgrid domains.
            subset_grid_field_name: Optional, default None) Shapefile
                field name to be stored in the index file.

        Raises: Exception when given subset grid shapefile does not exist or
            does not include any grid polygons intersecting with given extent.

        Returns:
            Instance of `RegularGrid` representing the extended generated
            grid whose extent matches the union of all intersecting subset grid
            polygons.
        """
        shp = ogr.Open(subset_grid_shp)
        layer = shp.GetLayer()

        # Create OGR Geometry from ocean model grid extent
        ring = ogr.Geometry(ogr.wkbLinearRing)
        ring.AddPoint(lon_min, lat_max)
        ring.AddPoint(lon_min, lat_min)
        ring.AddPoint(lon_max, lat_min)
        ring.AddPoint(lon_max, lat_max)
        ring.AddPoint(lon_min, lat_max)
        # Create polygon
        ofs_poly = ogr.Geometry(ogr.wkbPolygon)
        ofs_poly.AddGeometry(ring)

        # Get the EPSG value from the import shapefile and transform to WGS84
        spatial_ref = layer.GetSpatialRef()
        shp_srs = spatial_ref.GetAttrValue('AUTHORITY', 1)
        source = osr.SpatialReference()
        source.ImportFromEPSG(int(shp_srs))
        target = osr.SpatialReference()
        target.ImportFromEPSG(4326)
        transform = osr.CoordinateTransformation(source, target)
        ofs_poly.Transform(transform)

        # Find the intersection between grid polygon and ocean model grid extent
        subset_polys = {}
        fids = []
        fields = {}
        fid = 0
        for feature in layer:
            geom = feature.GetGeometryRef()
            if ofs_poly.Intersects(geom):
                subset_polys[fid] = geom.ExportToJson()
                if subset_grid_field_name is not None:
                    field_name = feature.GetField(str(subset_grid_field_name))
                    fields.update({fid: field_name})
                    fids.append(fid)
                else:
                    fids.append(fid)
            fid += 1

        if len(fids) == 0:
            raise Exception('Given subset grid shapefile contains no polygons that intersect with model domain; cannot proceed.')

        # Use a single subset polygon to calculate x/y cell sizes. This ensures
        # that cells do not fall on the border between two grid polygons.
        single_polygon = ogr.Geometry(ogr.wkbMultiPolygon)
        single_polygon.AddGeometry(ogr.CreateGeometryFromJson(subset_polys[fids[0]]))
        sp_x_min, sp_x_max, sp_y_min, sp_y_max = single_polygon.GetEnvelope()

        cellsize_x, cellsize_y = RegularGrid.calc_cellsizes(sp_x_min, sp_y_min, sp_x_max, sp_y_max, target_cellsize_meters)

        # Combine identified subset grid polygons into single multipolygon to
        # calculate full extent of all combined subset grids
        multipolygon = ogr.Geometry(ogr.wkbMultiPolygon)
        for fid in fids:
            multipolygon.AddGeometry(ogr.CreateGeometryFromJson(subset_polys[fid]))

        (x_min, x_max, y_min, y_max) = multipolygon.GetEnvelope()
        full_reg_grid = RegularGrid(x_min, y_min, x_max, y_max, cellsize_x, cellsize_y)

        # Create NetCDF dimensions & coordinate variables using dimension sizes
        # from regular grid
        self.create_dims_coord_vars(len(full_reg_grid.y_coords), len(full_reg_grid.x_coords))
        # Populate NetCDF coordinate variables using regular grid coordinates
        self.var_x[:] = full_reg_grid.x_coords[:]
        self.var_y[:] = full_reg_grid.y_coords[:]
        self.nc_file.gridSpacingLongitude = full_reg_grid.cellsize_x
        self.nc_file.gridSpacingLatitude = full_reg_grid.cellsize_y

        # Create subgrid dimension/variables
        self.create_subgrid_dims_vars(len(subset_polys), subset_grid_field_name)
        # Calculate subgrid mask ranges, populate subgrid ID
        for subgrid_index, fid in enumerate(fids):
            self.var_subgrid_id[subgrid_index] = fid
            if subset_grid_field_name is not None:
                self.var_subgrid_name[subgrid_index] = fields[fid]

            # Convert OGR geometry to shapely geometry
            subset_poly_shape = shape(json.loads(subset_polys[fid]))
            min_x_coord = subset_poly_shape.bounds[0]
            max_x_coord = subset_poly_shape.bounds[2]
            min_y_coord = subset_poly_shape.bounds[1]
            max_y_coord = subset_poly_shape.bounds[3]

            subgrid_x_min = None
            subgrid_x_max = None
            subgrid_y_min = None
            subgrid_y_max = None

            for i, x in enumerate(self.var_x):
                if x >= min_x_coord:
                    subgrid_x_min = i
                    break
            count_x = round(((max_x_coord - min_x_coord) / full_reg_grid.cellsize_x))

            for i, y in enumerate(self.var_y):
                if y >= min_y_coord:
                    subgrid_y_min = i
                    break
            count_y = round(((max_y_coord - min_y_coord) / full_reg_grid.cellsize_y))

            subgrid_x_max = subgrid_x_min + count_x - 1
            subgrid_y_max = subgrid_y_min + count_y - 1

            self.var_subgrid_x_min[subgrid_index] = subgrid_x_min
            self.var_subgrid_x_max[subgrid_index] = subgrid_x_max
            self.var_subgrid_y_min[subgrid_index] = subgrid_y_min
            self.var_subgrid_y_max[subgrid_index] = subgrid_y_max

        return full_reg_grid
예제 #6
0
tfb = tfz.open("Train Station Codes and Chinese Names.csv", "r")
tf = codecs.getreader('utf-16')(tfb)

sfName = "TrainStation_Oct2017/MRTLRTStnPtt"
shp = esri_driver.Open('/vsizip/stations.zip/' + sfName + '.shp',
                       0)  # read only
if shp is None:
    print('Cannot open shapefile')
    exit(1)

layer = shp.GetLayer(0)

# Setup a transform to EPSG 4326
targetsr = osr.SpatialReference()
targetsr.ImportFromEPSG(4326)
transform = osr.CoordinateTransformation(layer.GetSpatialRef(), targetsr)

# Read in the station names
tf_reader = csv.DictReader(tf, delimiter="\t")

names = {}
for tf_record in tf_reader:
    names[tf_record['stn_code']] = (tf_record['mrt_station_english'],
                                    tf_record['mrt_station_chinese'])

coordinates = {}

for shapeRec in layer:
    geom = shapeRec.GetGeometryRef()
    geom.Transform(transform)
    for stn_id in map(lambda x: x.strip(),
예제 #7
0
def FlowlineToPoint(in_drainage_line,
                    river_id,
                    out_csv_file,
                    file_geodatabase=None):
    """
    Converts flowline feature to a list of centroid points with their rivid
    in EPSG:4326.

    Parameters
    ----------
    in_drainage_line: str
        Path to the stream network (i.e. Drainage Line) shapefile.
    river_id: str
        The name of the field with the river ID
        (Ex. 'HydroID', 'COMID', or 'LINKNO').
    out_csv_file: str
        Path to the output csv file with the centroid points.
    file_geodatabase: str, optional
        Path to the file geodatabase. If you use this option, in_drainage_line
         is the name of the stream network feature class
         (WARNING: Not always stable with GDAL).


    Example::

        from RAPIDpy.gis.centroid import FlowlineToPoint

        FlowlineToPoint(
            in_drainage_line='/path/to/drainageline.shp',
            river_id='LINKNO',
            out_csv_file='/path/to/comid_lat_lon_z.csv')

    """
    ogr_drainage_line_shapefile_lyr, ogr_drainage_line_shapefile = \
        open_shapefile(in_drainage_line, file_geodatabase)

    ogr_drainage_line_shapefile_lyr_proj = \
        ogr_drainage_line_shapefile_lyr.GetSpatialRef()
    osr_geographic_proj = osr.SpatialReference()
    osr_geographic_proj.ImportFromEPSG(4326)
    proj_transform = None
    if ogr_drainage_line_shapefile_lyr_proj != osr_geographic_proj:
        proj_transform = osr.CoordinateTransformation(
            ogr_drainage_line_shapefile_lyr_proj, osr_geographic_proj)

    # print valid field names to table
    with open_csv(out_csv_file, 'w') as outfile:
        writer = csv_writer(outfile)
        writer.writerow(['rivid', 'lat', 'lon', 'z'])
        for feature in ogr_drainage_line_shapefile_lyr:
            feat_geom = feature.GetGeometryRef()
            if proj_transform:
                feat_geom.Transform(proj_transform)
            centroid = feat_geom.Centroid()
            centroid_pt = centroid.GetPoint(0)
            writer.writerow([
                feature.GetField(river_id), centroid_pt[1], centroid_pt[0],
                centroid_pt[2]
            ])

    del ogr_drainage_line_shapefile
예제 #8
0
def ParameterGenerator(S2TileGranule, SrcEPSG, TargetEPSG, ReprojectedImgPath,
                       ParOutPath):
    st_time = time.time()
    src_srs = osr.SpatialReference()
    src_srs.ImportFromEPSG(SrcEPSG)
    target_srs = osr.SpatialReference()
    target_srs.ImportFromEPSG(TargetEPSG)
    ct = osr.CoordinateTransformation(src_srs, target_srs)
    ct_inv = osr.CoordinateTransformation(target_srs, src_srs)

    g = gdal.Open(S2TileGranule)
    geo_t = g.GetGeoTransform()
    x_size = g.RasterXSize  # Raster xsize
    y_size = g.RasterYSize  # Raster ysize
    pixel_spacing = geo_t[1]

    # 50度带的参数
    p1x, p1y = geo_t[0], geo_t[3]
    p2x, p2y = geo_t[0] + pixel_spacing * x_size, geo_t[3]
    p3x, p3y = geo_t[0] + pixel_spacing * x_size, geo_t[
        3] - pixel_spacing * y_size
    p4x, p4y = geo_t[0], geo_t[3] - pixel_spacing * y_size

    end_time1 = time.time()
    print("1", end_time1 - st_time)
    # 投影后顶点坐标
    rep1x, rep1y = ct.TransformPoint(p1x, p1y)[0:2]
    rep2x, rep2y = ct.TransformPoint(p2x, p2y)[0:2]
    rep3x, rep3y = ct.TransformPoint(p3x, p3y)[0:2]
    rep4x, rep4y = ct.TransformPoint(p4x, p4y)[0:2]

    minX = min(rep1x, rep4x)
    maxX = max(rep2x, rep3x)
    minY = min(rep3y, rep4y)
    maxY = max(rep1y, rep2y)

    # 49度带的对角坐标
    ulx = int(minX / pixel_spacing) * pixel_spacing
    uly = int(np.ceil((maxY) / pixel_spacing)) * pixel_spacing
    lrx = int(np.ceil((maxX) / pixel_spacing)) * pixel_spacing
    lry = int(minY / pixel_spacing) * pixel_spacing
    print('Geotransform', [ulx, pixel_spacing, 0, uly, 0, -pixel_spacing])
    end_time2 = time.time()
    print("2", end_time2 - end_time1)

    # 49度带的宽高
    Width = int((lrx - ulx) / pixel_spacing)
    Heigth = int((uly - lry) / pixel_spacing)
    print("W H", Width, Heigth)

    print(ulx, uly, Width, Heigth)

    WD1 = ulx + np.repeat(a=[np.arange(Width)], repeats=Heigth, axis=0
                          ).flatten() * pixel_spacing + 0.5 * pixel_spacing
    HD1 = uly - np.repeat(a=np.arange(Heigth),
                          repeats=Width) * pixel_spacing - 0.5 * pixel_spacing
    Pair = np.column_stack((WD1, HD1))

    end_time3 = time.time()
    print("3", end_time3 - end_time2)

    # 49度带转50度
    Pair = ct_inv.TransformPoints(Pair)
    end_time4 = time.time()
    print("4", end_time4 - end_time3)

    # print(np.array(Pair).reshape(1926,1927,3))
    PairX = np.array([p[0] for p in Pair]).reshape(Heigth, Width)
    PairY = np.array([p[1] for p in Pair]).reshape(Heigth, Width)
    # print(PairX)
    mask = (PairX < p1x) | (PairX >= p2x) | (PairY > p1y) | (PairY <= p4y)

    PairX[mask] = 0
    PairY[mask] = 0
    Valid = PairX != 0

    COL = np.floor((PairX - p1x) / pixel_spacing).astype(np.int32)
    ROW = np.floor((p1y - PairY) / pixel_spacing).astype(np.int32)

    ECord = WD1.reshape(Heigth, Width)
    NCord = HD1.reshape(Heigth, Width)

    end_time5 = time.time()
    print("5", end_time5 - end_time4)

    ParaMeterX = np.zeros(shape=(y_size, x_size), dtype=np.float)
    ParaMeterY = np.zeros(shape=(y_size, x_size), dtype=np.float)
    ParaMeterXGapFiller = np.zeros(shape=(y_size, x_size), dtype=np.float)
    ParaMeterYGapFiller = np.zeros(shape=(y_size, x_size), dtype=np.float)

    ValidCOL = COL[Valid]
    ValidROW = ROW[Valid]

    ValidRC = ValidCOL + ValidROW * x_size
    np.put(a=ParaMeterX, ind=ValidRC, v=ECord[Valid])
    np.put(a=ParaMeterY, ind=ValidRC, v=NCord[Valid])

    print(ParaMeterY.min())
    end_time6 = time.time()
    print("6", end_time6 - end_time5)

    ReprojectedImg = gdal.Open(ReprojectedImgPath).ReadAsArray()
    ReprojectedImg[mask] = -2
    # from matplotlib import pyplot as plt
    # plt.imshow(ReprojectedImg)
    # plt.show()
    Empty = np.where(ReprojectedImg == 0)
    EpValidCOL = COL[Empty]
    EpValidROW = ROW[Empty]

    EpValidRC = EpValidCOL + EpValidROW * x_size
    np.put(a=ParaMeterXGapFiller, ind=EpValidRC, v=ECord[Empty])
    np.put(a=ParaMeterYGapFiller, ind=EpValidRC, v=NCord[Empty])

    Xpath = os.path.join(ParOutPath,
                         'TestRepX{}GapFiller.tif'.format(pixel_spacing))
    Ypath = os.path.join(ParOutPath,
                         'TestRepY{}GapFiller.tif'.format(pixel_spacing))
    write_Img(ParaMeterXGapFiller,
              Xpath,
              src_srs,
              geo_t,
              x_size,
              y_size,
              im_bands=1,
              dtype=gdal.GDT_UInt32)
    write_Img(ParaMeterYGapFiller,
              Ypath,
              src_srs,
              geo_t,
              x_size,
              y_size,
              im_bands=1,
              dtype=gdal.GDT_UInt32)

    end_time7 = time.time()
    print("7", end_time7 - end_time6)
    end_time = time.time()

    print("I am done ! take time for {} s".format(end_time - st_time))
def main():
    # pixel sizes between images are considered equal if diff is less than pixel_eps (UTM)
    pixel_eps = 0.01

    i = readInputs()
    print('PreImage: ' + i.PreImage)
    print('PostImage: ' + i.PostImage)
    prefile = i.PreImage
    postfile = i.PostImage

    # geographic coords.
    pre_multipolygon, gcsSpatialRef = geotiff2boundary(prefile)
    pre_raster = gdal.Open(prefile)
    pre_outSpatialRef = osr.SpatialReference()
    pre_outSpatialRef.ImportFromWkt(pre_raster.GetProjectionRef())
    coordTransPre = osr.CoordinateTransformation(gcsSpatialRef,
                                                 pre_outSpatialRef)
    pre_gt = pre_raster.GetGeoTransform()

    post_multipolygon, gcsSpatialRef = geotiff2boundary(postfile)
    post_raster = gdal.Open(postfile)
    post_outSpatialRef = osr.SpatialReference()
    post_outSpatialRef.ImportFromWkt(post_raster.GetProjectionRef())
    coordTransPost = osr.CoordinateTransformation(gcsSpatialRef,
                                                  post_outSpatialRef)
    post_gt = post_raster.GetGeoTransform()

    # determine pixel width
    if abs(pre_gt[1] - post_gt[1]) < pixel_eps:
        pixelWidth = abs(pre_gt[1])
    else:
        print('Error: Pixel widths differ between images ' + prefile +
              ' and ' + postfile)
        sys.exit(1)

    # determine pixel height
    if abs(pre_gt[5] - post_gt[5]) < pixel_eps:
        pixelHeight = abs(pre_gt[5])
    else:
        print('Error: Pixel heights differ between images ' + prefile +
              ' and ' + postfile)
        sys.exit(1)

    # test geotiff2boundary(inGeotiff)

    # re-project post_multipolygon if needed
    if pre_outSpatialRef == post_outSpatialRef:
        pre_multipolygon.Transform(coordTransPre)
        post_multipolygon.Transform(coordTransPost)
    else:
        print('Needed to re-project post_multipolygon.')
        pre_multipolygon.Transform(coordTransPre)
        post_multipolygon.Transform(coordTransPre)

    # shapefile_generation(pre_outSpatialRef,pre_multipolygon,'pre_polygon.shp')
    # coordTrans = osr.CoordinateTransformation(vectorSpatialRef, rasterSpatialRef)
    # polygon.Transform(coordTrans)

    # shapefile_generation(post_outSpatialRef,post_multipolygon,'post_polygon.shp')

    # print 'pre_multipolygon:'
    # print pre_multipolygon
    # print ' '
    # print 'pre_outSpatialRef:'
    # print pre_outSpatialRef
    # print ' '
    # print 'post_multipolygon:'
    # print post_multipolygon
    # print ' '
    # print 'post_outSpatialRef:'
    # print post_outSpatialRef
    # print ' '

    if i.aoi is None:
        # if an area-of-interest is NOT defined
        overlap_poly = overlap_polygons(pre_multipolygon, post_multipolygon)
        overlap_SpatialRef = pre_outSpatialRef
    else:
        # if an area-of-interest is defined
        overlap_poly_temp = overlap_polygons(pre_multipolygon,
                                             post_multipolygon)
        overlap_SpatialRef = pre_outSpatialRef
        AOI_poly, AOI_SpatialRef = shape2geometry_only(i.aoi)
        AOI_poly.Transform(coordTransPre)
        if ogr.Geometry.Contains(overlap_poly_temp, AOI_poly):
            # if area-of-interest is fully contained by the intersecton of granule scenes
            overlap_poly = AOI_poly
        elif ogr.Geometry.Overlaps(overlap_poly_temp, AOI_poly):
            # if only part of the area-of-interest lies within the intersection of granule scenes
            overlap_poly = overlap_polygons(overlap_poly_temp, AOI_poly)
        else:
            # if the area-of-interest is completely disjointed from the intersection of the granule scenes
            print(
                'Error: Area of interest is disjointed from the intersection of the granule scenes.'
            )
            print(
                '       The intersection of scenes will be used for analysis instead of the area of interest.'
            )
            overlap_poly = overlap_poly_temp

    # overlap_poly = pre_multipolygon.Intersection(post_multipolygon)
    # print overlap_poly
    # print overlap_poly.GetEnvelope()

    # print dir(overlap_poly)
    # print overlap_poly.GetGeometryName()
    # if overlap_poly.GetGeometryName()=='MULTIPOLYGON':
    #     for polygon in overlap_poly:
    #         print polygon.GetEnvelope()
    #         print dir(polygon)
    # print overlap_poly
    # print overlap_poly.GetPoints()
    # print overlap_poly.GetExtent()

    env = overlap_poly.GetEnvelope()
    # print 'xmin='+str(env[0])
    # print 'xmax='+str(env[1])
    # print 'ymin='+str(env[2])
    # print 'ymax='+str(env[3])
    # print 'xRange='+str(env[1]-env[0])
    # print 'yRange='+str(env[3]-env[2])

    xMin = env[0]
    xMax = env[1]
    yMin = env[2]
    yMax = env[3]
    xRange = xMax - xMin
    yRange = yMax - yMin
    colRange = np.ceil((xRange + 1) / pixelWidth)
    rowRange = np.ceil((yRange + 1) / pixelHeight)

    # print 'pre width and height = '+str(pre_gt[1])+' '+str(pre_gt[5])
    # print 'post width and height = '+str(post_gt[1])+' '+str(post_gt[5])
    # print 'number of columns = '+str(colRange)
    # print 'number of rows = '+str(rowRange)

    # generate overlap.shp
    shapefile_generation(overlap_SpatialRef, overlap_poly, 'overlap.shp')

    if i.bb:
        # generate overlap_BB.shp (shapefile of bounding box of overlap.shp)
        ring_BB = ogr.Geometry(ogr.wkbLinearRing)
        ring_BB.AddPoint_2D(xMin, yMin)
        ring_BB.AddPoint_2D(xMin, yMax)
        ring_BB.AddPoint_2D(xMax, yMax)
        ring_BB.AddPoint_2D(xMax, yMin)
        ring_BB.AddPoint_2D(xMin, yMin)
        overlap_BB_poly = ogr.Geometry(ogr.wkbPolygon)
        overlap_BB_poly.AddGeometry(ring_BB)
        shapefile_generation(overlap_SpatialRef, overlap_BB_poly,
                             'overlap_BB.shp')
        CropShapeFile = 'overlap_BB.shp'
    else:
        CropShapeFile = 'overlap.shp'

    # cmd1=' '.join(['gdalwarp','-cutline overlap.shp','-crop_to_cutline', \
    #               '-overwrite','-dstnodata 0',prefile,'PreImage_Crop_geo.tif'])
    # cmd2=' '.join(['gdalwarp','-cutline overlap.shp','-crop_to_cutline', \
    #               '-overwrite','-dstnodata 0',postfile,'PostImage_Crop_geo.tif'])
    # os.system(cmd1)
    # os.system(cmd2)

    if colRange <= i.c and rowRange <= i.r:
        # if the bounding box of the overlap is small enough, then crop it and use it
        print('Cropping images...')
        gdal.Warp('PreImage_Crop_geo.tif',
                  prefile,
                  cutlineDSName=CropShapeFile,
                  cropToCutline=True,
                  dstNodata=0)
        gdal.Warp('PostImage_Crop_geo.tif',
                  postfile,
                  cutlineDSName=CropShapeFile,
                  cropToCutline=True,
                  dstNodata=0)
    else:
        # if the overlap is too large, decimate/resample the image
        xFactor = colRange / i.c
        yFactor = rowRange / i.r
        Factor = max(np.ceil(xFactor), np.ceil(yFactor))

        print('Cropping images...')
        gdal.Warp('pre_temp_geo.tif',
                  prefile,
                  cutlineDSName=CropShapeFile,
                  cropToCutline=True,
                  dstNodata=0)
        gdal.Warp('post_temp_geo.tif',
                  postfile,
                  cutlineDSName=CropShapeFile,
                  cropToCutline=True,
                  dstNodata=0)

        # down-sample and save final geotiffs
        gdal.Translate('PreImage_Crop_geo.tif',
                       'pre_temp_geo.tif',
                       xRes=pixelWidth * Factor,
                       yRes=pixelHeight * Factor,
                       resampleAlg='average',
                       noData=0)
        gdal.Translate('PostImage_Crop_geo.tif',
                       'post_temp_geo.tif',
                       xRes=pixelWidth * Factor,
                       yRes=pixelHeight * Factor,
                       resampleAlg='average',
                       noData=0)
        print('Needed to decimate/resample images by a factor of ' +
              str(Factor) + '...')

        # delete temporary geotiffs
        os.remove('pre_temp_geo.tif')
        os.remove('post_temp_geo.tif')
예제 #10
0
def reproject_vector( path, epsg_from=None, epsg_to=None):
    """ reproject a vector file (only the first layer!) (it does not save the dataset to disk)
    :param path: the path to the input vectorfile
    :param epsg_from: the input spatial reference; in None take the source reference
    :param epsg_to: the output spatial reference
    :return: the reprojected dataset
    """

    if not epsg_to: raise Exception("please, specify the output EPSG codes")

    inDataSet = None
    outDataSet = None
    inFeature = None
    outFeature = None
    outLayer = None

    try:

        driver = ogr.GetDriverByName('ESRI Shapefile')
        inDataSet = driver.Open(path, 0)  # 0 means read-only

        # define input SpatialReference
        if not epsg_from:
            layer = inDataSet.GetLayer()
            inSpatialRef = layer.GetSpatialRef()
        else:
            inSpatialRef = osr.SpatialReference()
            inSpatialRef.ImportFromEPSG(epsg_from)

        # define output SpatialReference
        outSpatialRef = osr.SpatialReference()
        outSpatialRef.ImportFromEPSG(epsg_to)

        # create the CoordinateTransformation
        coordTrans = osr.CoordinateTransformation(inSpatialRef, outSpatialRef)

        # get the first input layer and the geometry type
        inLayer = inDataSet.GetLayer()
        geotype = inLayer.GetGeomType()
        lname = inLayer.GetName()

        drv = ogr.GetDriverByName("ESRI Shapefile")
        outDataSet = drv.CreateDataSource("/vsimem/memory.shp")

        outLayer = outDataSet.CreateLayer(lname, srs=outSpatialRef, geom_type=geotype)

        # add fields
        inLayerDefn = inLayer.GetLayerDefn()

        for i in range(0, inLayerDefn.GetFieldCount()):
            fieldDefn = inLayerDefn.GetFieldDefn(i)
            outLayer.CreateField(fieldDefn)

        # get the output layer"s feature definition
        outLayerDefn = outLayer.GetLayerDefn()

        counter = 1

        # loop through the input features
        inFeature = inLayer.GetNextFeature()
        while inFeature:
            # get the input geometry
            geom = inFeature.GetGeometryRef()
            # reproject the geometry
            geom.Transform(coordTrans)
            # create a new feature
            outFeature = ogr.Feature(outLayerDefn)
            # set the geometry and attribute
            outFeature.SetGeometry(geom)
            for i in range(0, outLayerDefn.GetFieldCount()):
                outFeature.SetField(outLayerDefn.GetFieldDefn(i).GetNameRef(), inFeature.GetField(i))
            # add the feature to the shapefile
            outLayer.CreateFeature(outFeature)

            # destroy the features and get the next input feature
            if outFeature: outFeature = None
            inFeature = inLayer.GetNextFeature()

            counter += 1
            #print(counter)

        return outDataSet

    except RuntimeError as err:
        raise err
    except Exception as e:
        raise e

    finally:
        if inDataSet: outDataSet == None  # give back control to C++
        if outDataSet: outDataSet == None
        if outLayer: outLayer == None
        if inFeature: inFeature == None
        if outFeature: outFeature = None
예제 #11
0
# Open the image to get the geo data
src = gdal.Open(image)
# Load the image with opencv
img = cv2.imread(image)

# The source projection (wgs84, coordinate system used by gps)
source = osr.SpatialReference()
source.ImportFromWkt(__wgs84_wkt)

# The target projection (whatever is used by the geotiff image)
target = osr.SpatialReference()
target.ImportFromWkt(src.GetProjection())

# Create the transform and an inverse transform
__transform = osr.CoordinateTransformation(source, target)
__transform_inv = osr.CoordinateTransformation(target, source)

# Get the coordinates of the upper left and lower right point of the image
# (uses whatever coordinate system the image was encoded with)
ulx, xres, xskew, uly, yskew, yres = src.GetGeoTransform()
lrx = ulx + (src.RasterXSize * xres)
lry = uly + (src.RasterYSize * yres)

# Get the height and width of the image (in pixels)
(hei, wid, cha) = img.shape

# Determine values to interpolate between the geo coordinate system of
# the image and pixel values
xScale = wid / (lrx - ulx)
yScale = hei / (lry - uly)
예제 #12
0
    elif '_hnv' in plt_src.lower():
        sheet_type = 'HNV'

    if not os.path.isdir(tgt_dir):
        os.makedirs(tgt_dir)

    src_sr = osr.SpatialReference()
    src_sr.SetWellKnownGeogCS('WGS84')
    src_sr.SetUTM(utm_zone)

    tgt_sr = osr.SpatialReference()
    tgt_sr.SetWellKnownGeogCS('WGS84')

    gm_tpl = "http://maps.googleapis.com/maps/api/staticmap?center=[x],[y]&zoom=13&size=310x150&sensor=false&markers=color:green|[x],[y]"

    ct = osr.CoordinateTransformation(src_sr, tgt_sr)
    csv_reader = csv.DictReader(open(plt_src, 'rb'), delimiter=";")

    species = sorted(
        csv_reader.fieldnames[csv_reader.fieldnames.index('Humidity') + 1:])

    record_count = 0

    for row in csv_reader:
        # retrieving plot id and x and y coordinates
        plot = int(row['Plot'])
        x = int(row["X_UTM%d" % utm_zone])
        y = int(row["Y_UTM%d" % utm_zone])

        # incrementing record count
        record_count += 1
예제 #13
0
    def mod3dtokmz(self):
        """ Saves the 3D model and grids in a kmz file.
        Note:
        Only the boundary of the area is in degrees. The actual coordinates
        are still in meters.
        """

        mvis_3d = mvis3d.Mod3dDisplay()
        mvis_3d.lmod1 = self.lmod

        rev = 1  # should be 1 normally

        xrng = np.array(self.lmod.xrange, dtype=float)
        yrng = np.array(self.lmod.yrange, dtype=float)
        zrng = np.array(self.lmod.zrange, dtype=float)

        if 'Raster' in self.indata:
            wkt = self.indata['Raster'][0].wkt
        else:
            wkt = ''
        prjkmz = Exportkmz(wkt)
        tmp = prjkmz.exec_()

        if tmp == 0:
            return

        if prjkmz.proj.wkt == '':
            QtWidgets.QMessageBox.warning(self.parent, 'Warning',
                                          ' You need a projection!',
                                          QtWidgets.QMessageBox.Ok)
            return

        smooth = prjkmz.checkbox_smooth.isChecked()

        orig_wkt = prjkmz.proj.wkt
        orig = osr.SpatialReference()
        orig.ImportFromWkt(orig_wkt)

        targ = osr.SpatialReference()
        targ.SetWellKnownGeogCS('WGS84')
        prj = osr.CoordinateTransformation(orig, targ)

        res = prj.TransformPoint(xrng[0], yrng[0])
        lonwest, latsouth = res[0], res[1]
        res = prj.TransformPoint(xrng[1], yrng[1])
        loneast, latnorth = res[0], res[1]

        # Get Save Name
        filename = self.ifile

        self.showtext('kmz export starting...')

        # Move to 3d model tab to update the model stuff
        self.showtext('updating 3d model...')

        mvis_3d.spacing = [self.lmod.dxy, self.lmod.dxy, self.lmod.d_z]
        mvis_3d.origin = [xrng[0], yrng[0], zrng[0]]
        mvis_3d.gdata = self.lmod.lith_index[::1, ::1, ::-1]
        itmp = np.sort(np.unique(self.lmod.lith_index))
        itmp = itmp[itmp > 0]
        tmp = np.ones((255, 4)) * 255
        for i in itmp:
            tmp[i, :3] = self.lmod.mlut[i]
        mvis_3d.lut = tmp
        mvis_3d.update_model(smooth)

        self.showtext('creating kmz file')
        heading = str(0.)
        tilt = str(45.)  # angle from vertical
        lat = str(np.mean([latsouth, latnorth]))  # coord of object
        lon = str(np.mean([lonwest, loneast]))  # coord of object
        rng = str(max(xrng.ptp(), yrng.ptp(), zrng.ptp()))  # range to object
        alt = str(0)  # alt of object eye is looking at (meters)
        lato = str(latsouth)
        lono = str(lonwest)

        # update colors
        self.lmod.update_lith_list_reverse()

        dockml = ('<?xml version="1.0" encoding="UTF-8" standalone="no" ?>\r\n'
                  '<kml xmlns="http://www.opengis.net/kml/2.2" '
                  'xmlns:gx="http://www.google.com/kml/ext/2.2">\r\n'
                  '\r\n'
                  '  <Folder>\r\n'
                  '    <name>Lithological Model</name>\r\n'
                  '    <description>Created with PyGMI</description>\r\n'
                  '    <visibility>1</visibility>\r\n'
                  '    <LookAt>\r\n'
                  '      <heading>' + heading + '</heading>\r\n'
                  '      <tilt>' + tilt + '</tilt>\r\n'
                  '      <latitude>' + lat + '</latitude>\r\n'
                  '      <longitude>' + lon + '</longitude>\r\n'
                  '      <range>' + rng + '</range>\r\n'
                  '      <altitude>' + alt + '</altitude>\r\n'
                  '    </LookAt>\r\n')

        mvis_3d.update_for_kmz()

        modeldae = []
        lkey = list(mvis_3d.faces.keys())
        lkey.pop(lkey.index(0))
        lithcnt = -1

        alt = str(0)
        for lith in lkey:
            faces = np.array(mvis_3d.gfaces[lith])
            # Google wants the model to have origin (0,0)

            points = mvis_3d.gpoints[lith]

            if points == []:
                continue

            points -= mvis_3d.origin

            x = points[:, 0]
            y = points[:, 1]
            earthrad = 6378137.
            z = earthrad - np.sqrt(earthrad**2 - (x**2 + y**2))
            points[:, 2] -= z

            if rev == -1:
                points += [xrng.ptp(), yrng.ptp(), 0]

            norm = np.abs(mvis_3d.gnorms[lith])
            clrtmp = np.array(self.lmod.mlut[lith]) / 255.
            curmod = self.lmod.lith_list_reverse[lith]

            if len(points) > 60000:
                self.showtext(curmod + ' has too many points (' +
                              str(len(points)) + '). Not exported')
                points = points[:60000]
                norm = norm[:60000]
                faces = faces[faces.max(1) < 60000]

            lithcnt += 1

            dockml += ('    <Placemark>\r\n'
                       '      <name>' + curmod + '</name>\r\n'
                       '      <description></description>\r\n'
                       '      <Style id="default"/>\r\n'
                       '      <Model>\r\n'
                       '        <altitudeMode>absolute</altitudeMode>\r\n'
                       '        <Location>\r\n'
                       '          <latitude>' + lato + '</latitude>\r\n'
                       '          <longitude>' + lono + '</longitude>\r\n'
                       '          <altitude>' + str(alt) + '</altitude>\r\n'
                       '        </Location>\r\n'
                       '        <Orientation>\r\n'
                       '          <heading>0</heading>\r\n'
                       '          <tilt>0</tilt>\r\n'
                       '          <roll>0</roll>\r\n'
                       '        </Orientation>\r\n'
                       '        <Scale>\r\n'
                       '          <x>1</x>\r\n'
                       '          <y>1</y>\r\n'
                       '          <z>1</z>\r\n'
                       '        </Scale>\r\n'
                       '        <Link>\r\n'
                       '          <href>models/mod3d' + str(lithcnt) +
                       '.dae</href>\r\n'
                       '        </Link>\r\n'
                       '      </Model>\r\n'
                       '    </Placemark>\r\n')

            position = str(points.flatten().tolist())
            position = position.replace('[', '')
            position = position.replace(']', '')
            position = position.replace(',', '')
            vertex = str(faces.flatten().tolist())
            vertex = vertex.replace('[', '')
            vertex = vertex.replace(']', '')
            vertex = vertex.replace(',', '')
            normal = str(norm.flatten().tolist())
            normal = normal.replace('[', '')
            normal = normal.replace(']', '')
            normal = normal.replace(',', '')
            color = str(clrtmp.flatten().tolist())
            color = color.replace('[', '')
            color = color.replace(']', '')
            color = color.replace(',', '')

            modeldae.append(
                '<?xml version="1.0" encoding="UTF-8" standalone="no" ?>\r\n'
                '<COLLADA xmlns="http://www.collada.org/2005'
                '/11/COLLADASchema" '
                'version="1.4.1">\r\n'
                '  <asset>\r\n'
                '    <contributor>\r\n'
                '      <authoring_tool>PyGMI</authoring_tool>\r\n'
                '    </contributor>\r\n'
                '    <created>2012-03-01T10:36:38Z</created>\r\n'
                '    <modified>2012-03-01T10:36:38Z</modified>\r\n'
                '    <up_axis>Z_UP</up_axis>\r\n'
                '  </asset>\r\n'
                '  <library_visual_scenes>\r\n'
                '    <visual_scene id="ID1">\r\n'
                '      <node name="SketchUp">\r\n'
                '        <node id="ID2" name="instance_0">\r\n'
                '          <matrix>    1 0 0 0 \r\n'
                '                      0 1 0 0 \r\n'
                '                      0 0 1 0 \r\n'
                '                      0 0 0 1 \r\n'
                '          </matrix>\r\n'
                '          <instance_node url="#ID3" />\r\n'
                '        </node>\r\n'
                '      </node>\r\n'
                '    </visual_scene>\r\n'
                '  </library_visual_scenes>\r\n'
                '  <library_nodes>\r\n'
                '    <node id="ID3" name="skp489E">\r\n'
                '      <instance_geometry url="#ID4">\r\n'
                '        <bind_material>\r\n'
                '          <technique_common>\r\n'
                '            <instance_material symbol="Material2"'
                ' target="#ID5">\r\n'
                '              <bind_vertex_input semantic="UVSET0" '
                'input_semantic="TEXCOORD" input_set="0" />\r\n'
                '            </instance_material>\r\n'
                '          </technique_common>\r\n'
                '        </bind_material>\r\n'
                '      </instance_geometry>\r\n'
                '    </node>\r\n'
                '  </library_nodes>\r\n'
                '  <library_geometries>\r\n'
                '    <geometry id="ID4">\r\n'
                '      <mesh>\r\n'
                '        <source id="ID7">\r\n'
                '          <float_array id="ID10" count="' + str(points.size) +
                '">' + position + '          </float_array>\r\n'
                '          <technique_common>\r\n'
                '            <accessor count="' + str(points.shape[0]) +
                '" source="#ID10" stride="3">\r\n'
                '              <param name="X" type="float" />\r\n'
                '              <param name="Y" type="float" />\r\n'
                '              <param name="Z" type="float" />\r\n'
                '            </accessor>\r\n'
                '          </technique_common>\r\n'
                '        </source>\r\n'
                '        <source id="ID8">\r\n'
                '          <float_array id="ID11" count="' + str(norm.size) +
                '">' + normal + '          </float_array>\r\n'
                '          <technique_common>\r\n'
                '            <accessor count="' + str(norm.shape[0]) +
                '" source="#ID11" stride="3">\r\n'
                '              <param name="X" type="float" />\r\n'
                '              <param name="Y" type="float" />\r\n'
                '              <param name="Z" type="float" />\r\n'
                '            </accessor>\r\n'
                '          </technique_common>\r\n'
                '        </source>\r\n'
                '        <vertices id="ID9">\r\n'
                '          <input semantic="POSITION" source="#ID7" />\r\n'
                '          <input semantic="NORMAL" source="#ID8" />\r\n'
                '        </vertices>\r\n'
                '        <triangles count="' + str(faces.shape[0]) +
                '" material="Material2">\r\n'
                '          <input offset="0" semantic="VERTEX" '
                'source="#ID9" />\r\n'
                '          <p>' + vertex + '</p>\r\n'
                '        </triangles>\r\n'
                '      </mesh>\r\n'
                '    </geometry>\r\n'
                '  </library_geometries>\r\n'
                '  <library_materials>\r\n'
                '    <material id="ID5" name="__auto_">\r\n'
                '      <instance_effect url="#ID6" />\r\n'
                '    </material>\r\n'
                '  </library_materials>\r\n'
                '  <library_effects>\r\n'
                '    <effect id="ID6">\r\n'
                '      <profile_COMMON>\r\n'
                '        <technique sid="COMMON">\r\n'
                '          <lambert>\r\n'
                '            <diffuse>\r\n'
                '              <color>' + color + '</color>\r\n'
                '            </diffuse>\r\n'
                '          </lambert>\r\n'
                '        </technique>\r\n'
                '        <extra> />\r\n'
                '          <technique profile="GOOGLEEARTH"> />\r\n'
                '            <double_sided>1</double_sided> />\r\n'
                '          </technique> />\r\n'
                '        </extra> />\r\n'
                '      </profile_COMMON>\r\n'
                '    </effect>\r\n'
                '  </library_effects>\r\n'
                '  <scene>\r\n'
                '    <instance_visual_scene url="#ID1" />\r\n'
                '  </scene>\r\n'
                '</COLLADA>')

        zfile = zipfile.ZipFile(filename, 'w')
        for i, _ in enumerate(modeldae):
            zfile.writestr('models\\mod3d' + str(i) + '.dae', modeldae[i])

        for i in self.lmod.griddata:
            x_1, x_2, y_1, y_2 = self.lmod.griddata[i].extent

            res = prj.TransformPoint(x_1, y_1)
            lonwest, latsouth = res[0], res[1]
            res = prj.TransformPoint(x_2, y_2)
            loneast, latnorth = res[0], res[1]

            dockml += ('    <GroundOverlay>\r\n'
                       '        <name>' + i + '</name>\r\n'
                       '        <description></description>\r\n'
                       '        <Icon>\r\n'
                       '            <href>models/' + i + '.png</href>\r\n'
                       '        </Icon>\r\n'
                       '        <LatLonBox>\r\n'
                       '            <north>' + str(latnorth) + '</north>\r\n'
                       '            <south>' + str(latsouth) + '</south>\r\n'
                       '            <east>' + str(loneast) + '</east>\r\n'
                       '            <west>' + str(lonwest) + '</west>\r\n'
                       '            <rotation>0.0</rotation>\r\n'
                       '        </LatLonBox>\r\n'
                       '    </GroundOverlay>\r\n')

            fig = plt.figure('tmp930', frameon=False)
            ax1 = plt.Axes(fig, [0., 0., 1., 1.])
            ax1.set_axis_off()
            fig.add_axes(ax1)

            plt.imshow(self.lmod.griddata[i].data,
                       extent=(lonwest, loneast, latsouth, latnorth),
                       aspect='auto',
                       interpolation='nearest')
            plt.savefig('tmp930.png')

            zfile.write('tmp930.png', 'models\\' + i + '.png')
            os.remove('tmp930.png')

        dockml += ('  </Folder>\r\n' '  \r\n' '  </kml>')

        zfile.writestr('doc.kml', dockml)

        zfile.close()
        self.showtext('kmz export complete!')
예제 #14
0
def main():
    from dateutil.parser import parse

    try:
        from pygbif import occurrences
        from pygbif import species
    except ImportError:
        grass.fatal(
            _("Cannot import pygbif (https://github.com/sckott/pygbif)"
              " library."
              " Please install it (pip install pygbif)"
              " or ensure that it is on path"
              " (use PYTHONPATH variable)."))

    # Parse input options
    output = options["output"]
    mask = options["mask"]
    species_maps = flags["i"]
    no_region_limit = flags["r"]
    no_topo = flags["b"]
    print_species = flags["p"]
    print_species_table = flags["t"]
    print_species_shell = flags["g"]
    print_occ_number = flags["o"]
    allow_no_geom = flags["n"]
    hasGeoIssue = flags["s"]
    taxa_list = options["taxa"].split(",")
    institutionCode = options["institutioncode"]
    basisofrecord = options["basisofrecord"]
    recordedby = options["recordedby"].split(",")
    date_from = options["date_from"]
    date_to = options["date_to"]
    country = options["country"]
    continent = options["continent"]
    rank = options["rank"]

    # Define static variable
    # Initialize cat
    cat = 0
    # Number of occurrences to fetch in one request
    chunk_size = 300
    # lat/lon proj string
    latlon_crs = [
        "+proj=longlat +no_defs +a=6378137 +rf=298.257223563 +towgs84=0.000,0.000,0.000",
        "+proj=longlat +no_defs +a=6378137 +rf=298.257223563 +towgs84=0,0,0,0,0,0,0",
        "+proj=longlat +no_defs +a=6378137 +rf=298.257223563 +towgs84=0.000,0.000,0.000 +type=crs",
    ]
    # List attributes available in Darwin Core
    # not all attributes are returned in each request
    # to avoid key errors when accessing the dictionary returned by pygbif
    # presence of DWC keys in the returned dictionary is checked using this list
    # The number of keys in this list has to be equal to the number of columns
    # in the attribute table and the attributes written for each occurrence
    dwc_keys = [
        "key",
        "taxonRank",
        "taxonKey",
        "taxonID",
        "scientificName",
        "species",
        "speciesKey",
        "genericName",
        "genus",
        "genusKey",
        "family",
        "familyKey",
        "order",
        "orderKey",
        "class",
        "classKey",
        "phylum",
        "phylumKey",
        "kingdom",
        "kingdomKey",
        "eventDate",
        "verbatimEventDate",
        "startDayOfYear",
        "endDayOfYear",
        "year",
        "month",
        "day",
        "occurrenceID",
        "occurrenceStatus",
        "occurrenceRemarks",
        "Habitat",
        "basisOfRecord",
        "preparations",
        "sex",
        "type",
        "locality",
        "verbatimLocality",
        "decimalLongitude",
        "decimalLatitude",
        "coordinateUncertaintyInMeters",
        "geodeticDatum",
        "higerGeography",
        "continent",
        "country",
        "countryCode",
        "stateProvince",
        "gbifID",
        "protocol",
        "identifier",
        "recordedBy",
        "identificationID",
        "identifiers",
        "dateIdentified",
        "modified",
        "institutionCode",
        "lastInterpreted",
        "lastParsed",
        "references",
        "relations",
        "catalogNumber",
        "occurrenceDetails",
        "datasetKey",
        "datasetName",
        "collectionCode",
        "rights",
        "rightsHolder",
        "license",
        "publishingOrgKey",
        "publishingCountry",
        "lastCrawled",
        "specificEpithet",
        "facts",
        "issues",
        "extensions",
        "language",
    ]
    # Deinfe columns for attribute table
    cols = [
        ("cat", "INTEGER PRIMARY KEY"),
        ("g_search", "varchar(100)"),
        ("g_key", "integer"),
        ("g_taxonrank", "varchar(50)"),
        ("g_taxonkey", "integer"),
        ("g_taxonid", "varchar(50)"),
        ("g_scientificname", "varchar(255)"),
        ("g_species", "varchar(255)"),
        ("g_specieskey", "integer"),
        ("g_genericname", "varchar(255)"),
        ("g_genus", "varchar(50)"),
        ("g_genuskey", "integer"),
        ("g_family", "varchar(50)"),
        ("g_familykey", "integer"),
        ("g_order", "varchar(50)"),
        ("g_orderkey", "integer"),
        ("g_class", "varchar(50)"),
        ("g_classkey", "integer"),
        ("g_phylum", "varchar(50)"),
        ("g_phylumkey", "integer"),
        ("g_kingdom", "varchar(50)"),
        ("g_kingdomkey", "integer"),
        ("g_eventdate", "text"),
        ("g_verbatimeventdate", "varchar(50)"),
        ("g_startDayOfYear", "integer"),
        ("g_endDayOfYear", "integer"),
        ("g_year", "integer"),
        ("g_month", "integer"),
        ("g_day", "integer"),
        ("g_occurrenceid", "varchar(255)"),
        ("g_occurrenceStatus", "varchar(50)"),
        ("g_occurrenceRemarks", "varchar(50)"),
        ("g_Habitat", "varchar(50)"),
        ("g_basisofrecord", "varchar(50)"),
        ("g_preparations", "varchar(50)"),
        ("g_sex", "varchar(50)"),
        ("g_type", "varchar(50)"),
        ("g_locality", "varchar(255)"),
        ("g_verbatimlocality", "varchar(255)"),
        ("g_decimallongitude", "double precision"),
        ("g_decimallatitude", "double precision"),
        ("g_coordinateUncertaintyInMeters", "double precision"),
        ("g_geodeticdatum", "varchar(50)"),
        ("g_higerGeography", "varchar(255)"),
        ("g_continent", "varchar(50)"),
        ("g_country", "varchar(50)"),
        ("g_countryCode", "varchar(50)"),
        ("g_stateProvince", "varchar(50)"),
        ("g_gbifid", "varchar(255)"),
        ("g_protocol", "varchar(255)"),
        ("g_identifier", "varchar(50)"),
        ("g_recordedby", "varchar(255)"),
        ("g_identificationid", "varchar(255)"),
        ("g_identifiers", "text"),
        ("g_dateidentified", "text"),
        ("g_modified", "text"),
        ("g_institutioncode", "varchar(50)"),
        ("g_lastinterpreted", "text"),
        ("g_lastparsed", "text"),
        ("g_references", "varchar(255)"),
        ("g_relations", "text"),
        ("g_catalognumber", "varchar(50)"),
        ("g_occurrencedetails", "text"),
        ("g_datasetkey", "varchar(50)"),
        ("g_datasetname", "varchar(255)"),
        ("g_collectioncode", "varchar(50)"),
        ("g_rights", "varchar(255)"),
        ("g_rightsholder", "varchar(255)"),
        ("g_license", "varchar(50)"),
        ("g_publishingorgkey", "varchar(50)"),
        ("g_publishingcountry", "varchar(50)"),
        ("g_lastcrawled", "text"),
        ("g_specificepithet", "varchar(50)"),
        ("g_facts", "text"),
        ("g_issues", "text"),
        ("g_extensions", "text"),
        ("g_language", "varchar(50)"),
    ]

    # maybe no longer required in Python3
    set_output_encoding()
    # Set temporal filter if requested by user
    # Initialize eventDate filter
    eventDate = None
    # Check if date from is compatible (ISO compliant)
    if date_from:
        try:
            parse(date_from)
        except:
            grass.fatal("Invalid invalid start date provided")

        if date_from and not date_to:
            eventDate = "{}".format(date_from)
    # Check if date to is compatible (ISO compliant)
    if date_to:
        try:
            parse(date_to)
        except:
            grass.fatal("Invalid invalid end date provided")
        # Check if date to is after date_from
        if parse(date_from) < parse(date_to):
            eventDate = "{},{}".format(date_from, date_to)
        else:
            grass.fatal(
                "Invalid date range: End date has to be after start date!")
    # Set filter on basisOfRecord if requested by user
    if basisofrecord == "ALL":
        basisOfRecord = None
    else:
        basisOfRecord = basisofrecord
    # Allow also occurrences with spatial issues if requested by user
    hasGeospatialIssue = False
    if hasGeoIssue:
        hasGeospatialIssue = True
    # Allow also occurrences without coordinates if requested by user
    hasCoordinate = True
    if allow_no_geom:
        hasCoordinate = False

    # Set reprojection parameters
    # Set target projection of current LOCATION
    proj_info = grass.parse_command("g.proj", flags="g")
    target_crs = grass.read_command("g.proj", flags="fj").rstrip()
    target = osr.SpatialReference()

    # Prefer EPSG CRS definitions
    if proj_info["epsg"]:
        target.ImportFromEPSG(int(proj_info["epsg"]))
    else:
        target.ImportFromProj4(target_crs)

    # GDAL >= 3 swaps x and y axis, see: github.com/gdal/issues/1546
    if int(gdal_version[0]) >= 3:
        target.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)

    if target_crs == "XY location (unprojected)":
        grass.fatal("Sorry, XY locations are not supported!")

    # Set source projection from GBIF
    source = osr.SpatialReference()
    source.ImportFromEPSG(4326)
    # GDAL >= 3 swaps x and y axis, see: github.com/gdal/issues/1546
    if int(gdal_version[0]) >= 3:
        source.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)

    if target_crs not in latlon_crs:
        transform = osr.CoordinateTransformation(source, target)
        reverse_transform = osr.CoordinateTransformation(target, source)

    # Generate WKT polygon to use for spatial filtering if requested
    if mask:
        if len(mask.split("@")) == 2:
            m = VectorTopo(mask.split("@")[0], mapset=mask.split("@")[1])
        else:
            m = VectorTopo(mask)
        if not m.exist():
            grass.fatal("Could not find vector map <{}>".format(mask))
        m.open("r")
        if not m.is_open():
            grass.fatal("Could not open vector map <{}>".format(mask))

        # Use map Bbox as spatial filter if map contains <> 1 area
        if m.number_of("areas") == 1:
            region_pol = [area.to_wkt() for area in m.viter("areas")][0]
        else:
            bbox = (str(m.bbox()).replace("Bbox(", "").replace(
                " ", "").rstrip(")").split(","))
            region_pol = "POLYGON (({0} {1}, {0} {3}, {2} {3}, {2} {1}, {0} {1}))".format(
                bbox[2], bbox[0], bbox[3], bbox[1])
        m.close()
    else:
        # Do not limit import spatially if LOCATION is able to take global data
        if no_region_limit:
            if target_crs not in latlon_crs:
                grass.fatal("Import of data from outside the current region is"
                            "only supported in a WGS84 location!")
            region_pol = None
        else:
            # Limit import spatially to current region
            # if LOCATION is !NOT! able to take global data
            # to avoid pprojection ERRORS
            region = grass.parse_command("g.region", flags="g")
            region_pol = "POLYGON (({0} {1},{0} {3},{2} {3},{2} {1},{0} {1}))".format(
                region["e"], region["n"], region["w"], region["s"])

    # Do not reproject in latlon LOCATIONS
    if target_crs not in latlon_crs:
        pol = ogr.CreateGeometryFromWkt(region_pol)
        pol.Transform(reverse_transform)
        pol = pol.ExportToWkt()
    else:
        pol = region_pol

    # Create output map if not output maps for each species are requested
    if (not species_maps and not print_species and not print_species_shell
            and not print_occ_number and not print_species_table):
        mapname = output
        new = Vector(mapname)
        new.open("w", tab_name=mapname, tab_cols=cols)
        cat = 1

    # Import data for each species
    for s in taxa_list:
        # Get the taxon key if not the taxon key is provided as input
        try:
            key = int(s)
        except:
            try:
                species_match = species.name_backbone(s,
                                                      rank=rank,
                                                      strict=False,
                                                      verbose=True)
                key = species_match["usageKey"]
            except:
                grass.error(
                    "Data request for taxon {} failed. Are you online?".format(
                        s))
                continue

        # Return matching taxon and alternatives and exit
        if print_species:
            print("Matching taxon for {} is:".format(s))
            print("{} {}".format(species_match["scientificName"],
                                 species_match["status"]))
            if "alternatives" in list(species_match.keys()):
                print("Alternative matches might be: {}".format(s))
                for m in species_match["alternatives"]:
                    print("{} {}".format(m["scientificName"], m["status"]))
            else:
                print("No alternatives found for the given taxon")
            continue
        if print_species_shell:
            print("match={}".format(species_match["scientificName"]))
            if "alternatives" in list(species_match.keys()):
                alternatives = []
                for m in species_match["alternatives"]:
                    alternatives.append(m["scientificName"])
                print("alternatives={}".format(",".join(alternatives)))
            continue
        if print_species_table:
            if "alternatives" in list(species_match.keys()):
                if len(species_match["alternatives"]) == 0:
                    print("{0}|{1}|{2}|".format(
                        s, key, species_match["scientificName"]))
                else:
                    alternatives = []
                    for m in species_match["alternatives"]:
                        alternatives.append(m["scientificName"])
                    print("{0}|{1}|{2}|{3}".format(
                        s,
                        key,
                        species_match["scientificName"],
                        ",".join(alternatives),
                    ))
            continue
        try:
            returns_n = occurrences.search(
                taxonKey=key,
                hasGeospatialIssue=hasGeospatialIssue,
                hasCoordinate=hasCoordinate,
                institutionCode=institutionCode,
                basisOfRecord=basisOfRecord,
                recordedBy=recordedby,
                eventDate=eventDate,
                continent=continent,
                country=country,
                geometry=pol,
                limit=1,
            )["count"]
        except:
            grass.error(
                "Data request for taxon {} faild. Are you online?".format(s))
            returns_n = 0

        # Exit if search does not give a return
        # Print only number of returns for the given search and exit
        if print_occ_number:
            print("Found {0} occurrences for taxon {1}...".format(
                returns_n, s))
            continue
        elif returns_n <= 0:
            grass.warning(
                "No occurrences for current search for taxon {0}...".format(s))
            continue
        elif returns_n >= 200000:
            grass.warning(
                "Your search for {1} returns {0} records.\n"
                "Unfortunately, the GBIF search API is limited to 200,000 records per request.\n"
                "The download will be incomplete. Please consider to split up your search."
                .format(returns_n, s))

        # Get the number of chunks to download
        chunks = int(math.ceil(returns_n / float(chunk_size)))
        grass.verbose("Downloading {0} occurrences for taxon {1}...".format(
            returns_n, s))

        # Create a map for each species if requested using map name as suffix
        if species_maps:
            mapname = "{}_{}".format(s.replace(" ", "_"), output)

            new = Vector(mapname)
            new.open("w", tab_name=mapname, tab_cols=cols)
            cat = 0

        # Download the data from GBIF
        for c in range(chunks):
            # Define offset
            offset = c * chunk_size
            # Adjust chunk_size to the hard limit of 200,000 records in GBIF API
            # if necessary
            if offset + chunk_size >= 200000:
                chunk_size = 200000 - offset
            # Get the returns for the next chunk
            returns = occurrences.search(
                taxonKey=key,
                hasGeospatialIssue=hasGeospatialIssue,
                hasCoordinate=hasCoordinate,
                institutionCode=institutionCode,
                basisOfRecord=basisOfRecord,
                recordedBy=recordedby,
                eventDate=eventDate,
                continent=continent,
                country=country,
                geometry=pol,
                limit=chunk_size,
                offset=offset,
            )

            # Write the returned data to map and attribute table
            for res in returns["results"]:
                if target_crs not in latlon_crs:
                    point = ogr.CreateGeometryFromWkt("POINT ({} {})".format(
                        res["decimalLongitude"], res["decimalLatitude"]))
                    point.Transform(transform)
                    x = point.GetX()
                    y = point.GetY()
                else:
                    x = res["decimalLongitude"]
                    y = res["decimalLatitude"]

                point = Point(x, y)

                for k in dwc_keys:
                    if k not in list(res.keys()):
                        res.update({k: None})

                cat = cat + 1
                new.write(
                    point,
                    cat=cat,
                    attrs=(
                        "{}".format(s),
                        res["key"],
                        res["taxonRank"],
                        res["taxonKey"],
                        res["taxonID"],
                        res["scientificName"],
                        res["species"],
                        res["speciesKey"],
                        res["genericName"],
                        res["genus"],
                        res["genusKey"],
                        res["family"],
                        res["familyKey"],
                        res["order"],
                        res["orderKey"],
                        res["class"],
                        res["classKey"],
                        res["phylum"],
                        res["phylumKey"],
                        res["kingdom"],
                        res["kingdomKey"],
                        "{}".format(res["eventDate"])
                        if res["eventDate"] else None,
                        "{}".format(res["verbatimEventDate"])
                        if res["verbatimEventDate"] else None,
                        res["startDayOfYear"],
                        res["endDayOfYear"],
                        res["year"],
                        res["month"],
                        res["day"],
                        res["occurrenceID"],
                        res["occurrenceStatus"],
                        res["occurrenceRemarks"],
                        res["Habitat"],
                        res["basisOfRecord"],
                        res["preparations"],
                        res["sex"],
                        res["type"],
                        res["locality"],
                        res["verbatimLocality"],
                        res["decimalLongitude"],
                        res["decimalLatitude"],
                        res["coordinateUncertaintyInMeters"],
                        res["geodeticDatum"],
                        res["higerGeography"],
                        res["continent"],
                        res["country"],
                        res["countryCode"],
                        res["stateProvince"],
                        res["gbifID"],
                        res["protocol"],
                        res["identifier"],
                        res["recordedBy"],
                        res["identificationID"],
                        ",".join(res["identifiers"]),
                        "{}".format(res["dateIdentified"])
                        if res["dateIdentified"] else None,
                        "{}".format(res["modified"])
                        if res["modified"] else None,
                        res["institutionCode"],
                        "{}".format(res["lastInterpreted"])
                        if res["lastInterpreted"] else None,
                        "{}".format(res["lastParsed"])
                        if res["lastParsed"] else None,
                        res["references"],
                        ",".join(res["relations"]),
                        res["catalogNumber"],
                        "{}".format(res["occurrenceDetails"])
                        if res["occurrenceDetails"] else None,
                        res["datasetKey"],
                        res["datasetName"],
                        res["collectionCode"],
                        res["rights"],
                        res["rightsHolder"],
                        res["license"],
                        res["publishingOrgKey"],
                        res["publishingCountry"],
                        "{}".format(res["lastCrawled"])
                        if res["lastCrawled"] else None,
                        res["specificEpithet"],
                        ",".join(res["facts"]),
                        ",".join(res["issues"]),
                        ",".join(res["extensions"]),
                        res["language"],
                    ),
                )

                cat = cat + 1

        # Close the current map if a map for each species is requested
        if species_maps:
            new.table.conn.commit()
            new.close()
            if not no_topo:
                grass.run_command("v.build", map=mapname, option="build")

            # Write history to map
            grass.vector_history(mapname)

    # Close the output map if not a map for each species is requested
    if (not species_maps and not print_species and not print_species_shell
            and not print_occ_number and not print_species_table):
        new.table.conn.commit()
        new.close()
        if not no_topo:
            grass.run_command("v.build", map=mapname, option="build")

        # Write history to map
        grass.vector_history(mapname)
예제 #15
0
def GetCentreAndExtentOfRaster(DataDirectory, RasterFile):
    """
    This function takes a raster and returns the centrepoint and the extent in both degrees and metres. 
    
    Args:
        DataDirectory (str): the data directory with the basin raster
        RasterFile (str): the name of the raster

    Returns:
        The lat-long of the centrepoint, the x-y- extent in both degrees and metres 

    Author: SMM
    
    Date: 01/02/2018
    """

    print("Trying to create a shapefile.")
    print("The Data directory is: " + DataDirectory + " and the raster is: " +
          RasterFile)
    driver_name = "ESRI shapefile"
    driver = ogr.GetDriverByName(driver_name)

    # get the filename of the outfile.
    if not DataDirectory.endswith(os.sep):
        print(
            "You forgot the separator at the end of the directory, appending..."
        )
        DataDirectory = DataDirectory + os.sep

    # Get the raster prefix
    SplitRasterfile = RasterFile.split(".")
    RasterPrefix = SplitRasterfile[0]

    # get the espg of the raster
    FullFilename = DataDirectory + RasterFile
    ESPG_this_raster = GetUTMEPSG(FullFilename)
    ESPG_this_raster = str(ESPG_this_raster)
    print("The raster has coordinate of: " + ESPG_this_raster)
    ESPG_this_raster_split = ESPG_this_raster.split(":")
    ESPG_this_raster = ESPG_this_raster_split[-1]
    print("This ESPG is: " + str(ESPG_this_raster))

    # Get extent of raster
    [xmin, xmax, ymin, ymax] = GetRasterExtent(FullFilename)
    xproj_extent = xmax - xmin
    yproj_extent = ymax - ymin

    # Create ring
    ring = ogr.Geometry(ogr.wkbLinearRing)
    ring.AddPoint(xmin, ymin)
    ring.AddPoint(xmin, ymax)
    ring.AddPoint(xmax, ymax)
    ring.AddPoint(xmax, ymin)

    # Create a coordinate transformation
    source = osr.SpatialReference()
    source.ImportFromEPSG(int(ESPG_this_raster))

    target = osr.SpatialReference()
    target.ImportFromEPSG(4326)

    transform = osr.CoordinateTransformation(source, target)

    # now transform the ring so you can get coordinates in lat-long
    ring.Transform(transform)

    # now get the xmin,ymin, and xmax, ymax coords in lat-long
    pt1 = ring.GetPoint(0)
    min_long = pt1[0]
    min_lat = pt1[1]

    pt2 = ring.GetPoint(2)
    max_long = pt2[0]
    max_lat = pt2[1]

    extent_long = max_long - min_long
    extent_lat = max_lat - min_lat

    centre_long = min_long + extent_long * 0.5
    centre_lat = min_lat + extent_lat * 0.5

    return centre_lat, centre_long, extent_lat, extent_long, xproj_extent, yproj_extent
예제 #16
0
def move(filename, t_srs, s_srs=None, pixel_threshold=None):

    # -------------------------------------------------------------------------
    # Open the file.
    # -------------------------------------------------------------------------
    ds = gdal.Open(filename)

    # -------------------------------------------------------------------------
    # Compute the current (s_srs) locations of the four corners and center
    # of the image.
    # -------------------------------------------------------------------------
    corners_names = [
        'Upper Left', 'Lower Left', 'Upper Right', 'Lower Right', 'Center'
    ]

    corners_pixel_line = [(0, 0, 0), (0, ds.RasterYSize, 0),
                          (ds.RasterXSize, 0, 0),
                          (ds.RasterXSize, ds.RasterYSize, 0),
                          (ds.RasterXSize / 2.0, ds.RasterYSize / 2.0, 0.0)]

    orig_gt = ds.GetGeoTransform()

    corners_s_geo = []
    for item in corners_pixel_line:
        corners_s_geo.append(
            (orig_gt[0] + item[0] * orig_gt[1] + item[1] * orig_gt[2],
             orig_gt[3] + item[0] * orig_gt[4] + item[1] * orig_gt[5],
             item[2]))

    # -------------------------------------------------------------------------
    # Prepare a transformation from source to destination srs.
    # -------------------------------------------------------------------------
    if s_srs is None:
        s_srs = ds.GetProjectionRef()

    s_srs_obj = osr.SpatialReference()
    s_srs_obj.SetFromUserInput(s_srs)

    t_srs_obj = osr.SpatialReference()
    t_srs_obj.SetFromUserInput(t_srs)

    tr = osr.CoordinateTransformation(s_srs_obj, t_srs_obj)

    # -------------------------------------------------------------------------
    # Transform the corners
    # -------------------------------------------------------------------------

    corners_t_geo = tr.TransformPoints(corners_s_geo)

    # -------------------------------------------------------------------------
    #  Compute a new geotransform for the image in the target SRS.  For now
    #  we just use the top left, top right, and bottom left to produce the
    #  geotransform.  The result will be exact at these three points by
    #  definition, but if the underlying transformation is not affine it will
    #  be wrong at the center and bottom right.  It would be better if we
    #  used all five points for a least squares fit but that is a bit beyond
    #  me for now.
    # -------------------------------------------------------------------------
    ul = corners_t_geo[0]
    ur = corners_t_geo[2]
    ll = corners_t_geo[1]

    new_gt = (ul[0], (ur[0] - ul[0]) / ds.RasterXSize,
              (ll[0] - ul[0]) / ds.RasterYSize, ul[1],
              (ur[1] - ul[1]) / ds.RasterXSize,
              (ll[1] - ul[1]) / ds.RasterYSize)

    inv_new_gt = gdal.InvGeoTransform(new_gt)

    # -------------------------------------------------------------------------
    #  Report results for the five locations.
    # -------------------------------------------------------------------------

    corners_t_new_geo = []
    error_geo = []
    error_pixel_line = []
    corners_pixel_line_new = []

    print(
        '___Corner___ ________Original________  _______Adjusted_________   ______ Err (geo) ______ _Err (pix)_'
    )

    for i in range(len(corners_s_geo)):  # pylint: disable=consider-using-enumerate

        item = corners_pixel_line[i]
        corners_t_new_geo.append(
            (new_gt[0] + item[0] * new_gt[1] + item[1] * new_gt[2],
             new_gt[3] + item[0] * new_gt[4] + item[1] * new_gt[5], item[2]))

        error_geo.append((corners_t_new_geo[i][0] - corners_t_geo[i][0],
                          corners_t_new_geo[i][1] - corners_t_geo[i][1], 0.0))

        item = corners_t_geo[i]
        corners_pixel_line_new.append(
            (inv_new_gt[0] + item[0] * inv_new_gt[1] + item[1] * inv_new_gt[2],
             inv_new_gt[3] + item[0] * inv_new_gt[4] + item[1] * inv_new_gt[5],
             item[2]))

        error_pixel_line.append(
            (corners_pixel_line_new[i][0] - corners_pixel_line[i][0],
             corners_pixel_line_new[i][1] - corners_pixel_line[i][1],
             corners_pixel_line_new[i][2] - corners_pixel_line[i][2]))

        print('%-11s %s %s %s %5.2f %5.2f' %
              (corners_names[i], fmt_loc(s_srs_obj, corners_s_geo[i]),
               fmt_loc(t_srs_obj,
                       corners_t_geo[i]), fmt_loc(t_srs_obj, error_geo[i]),
               error_pixel_line[i][0], error_pixel_line[i][1]))

    print('')

    # -------------------------------------------------------------------------
    # Do we want to update the file?
    # -------------------------------------------------------------------------
    max_error = 0
    for err_item in error_pixel_line:
        this_error = math.sqrt(err_item[0] * err_item[0] +
                               err_item[1] * err_item[1])
        if this_error > max_error:
            max_error = this_error

    update = False
    if pixel_threshold is not None:
        if pixel_threshold > max_error:
            update = True

    # -------------------------------------------------------------------------
    # Apply the change coordinate system and geotransform.
    # -------------------------------------------------------------------------
    if update:
        ds = None
        ds = gdal.Open(filename, gdal.GA_Update)

        print('Updating file...')
        ds.SetGeoTransform(new_gt)
        ds.SetProjection(t_srs_obj.ExportToWkt())
        print('Done.')

    elif pixel_threshold is None:
        print(
            'No error threshold in pixels selected with -et, file not updated.'
        )

    else:
        print("""Maximum check point error is %.5f pixels which exceeds the
error threshold so the file has not been updated.""" % max_error)

    ds = None
예제 #17
0
def CreateShapefileOfRasterFootprint(DataDirectory, RasterFile):
    """
    This function takes a raster and creates a shapefile that is the footprint
    of the raster. Used for plotting the raster footprint on regional maps using
    basemap.
    Variously put together from:
    http://osgeo-org.1560.x6.nabble.com/gdal-dev-Creating-a-simple-shapefile-with-ogr-td3749101.html
    
    
    Args:
        DataDirectory (str): the data directory with the basin raster
        RasterFile (str): the name of the raster

    Returns:
        Shapefile of the raster footprint

    Author: SMM
    
    Date: 23/01/2018
    """

    print("Trying to create a shapefile.")
    print("The Data directory is: " + DataDirectory + " and the raster is: " +
          RasterFile)
    driver_name = "ESRI shapefile"
    driver = ogr.GetDriverByName(driver_name)

    # get the filename of the outfile.
    if not DataDirectory.endswith(os.sep):
        print(
            "You forgot the separator at the end of the directory, appending..."
        )
        DataDirectory = DataDirectory + os.sep

    # Get the raster prefix
    SplitRasterfile = RasterFile.split(".")
    RasterPrefix = SplitRasterfile[0]

    # get the espg of the raster
    FullFilename = DataDirectory + RasterFile
    ESPG_this_raster = GetUTMEPSG(FullFilename)
    ESPG_this_raster = str(ESPG_this_raster)
    print("The raster has coordinate of: " + ESPG_this_raster)
    ESPG_this_raster_split = ESPG_this_raster.split(":")
    ESPG_this_raster = ESPG_this_raster_split[-1]
    print("This ESPG is: " + str(ESPG_this_raster))

    # Get extent of raster
    [xmin, xmax, ymin, ymax] = GetRasterExtent(FullFilename)

    # Create ring
    ring = ogr.Geometry(ogr.wkbLinearRing)
    ring.AddPoint(xmin, ymin)
    ring.AddPoint(xmin, ymax)
    ring.AddPoint(xmax, ymax)
    ring.AddPoint(xmax, ymin)
    ring.AddPoint(xmin, ymin)

    # Create polygon
    poly = ogr.Geometry(ogr.wkbPolygon)
    poly.AddGeometry(ring)

    # Create a coordinate transformation
    source = osr.SpatialReference()
    source.ImportFromEPSG(int(ESPG_this_raster))

    target = osr.SpatialReference()
    target.ImportFromEPSG(4326)

    transform = osr.CoordinateTransformation(source, target)

    # now transformt the polygon
    poly.Transform(transform)

    # see what you got
    #print("The polygon is:")
    #print(poly.ExportToWkt())

    # create the data source
    OutFileName = DataDirectory + RasterPrefix + "_footprint.shp"
    print("The output shapefile is: " + OutFileName)
    datasource = driver.CreateDataSource(OutFileName)

    # create the layer
    layer = datasource.CreateLayer(OutFileName, target, ogr.wkbPolygon)
    feature = ogr.Feature(layer.GetLayerDefn())
    feature.SetGeometry(poly)
    layer.CreateFeature(feature)

    # Clean up
    feature.Destroy()
    datasource.Destroy()
예제 #18
0
def import_data(shapefile):
    fd, fname = tempfile.mkstemp(suffix=".zip")
    os.close(fd)

    f = open(fname, "wb")
    for chunk in shapefile.chunks():
        f.write(chunk)
    f.close()

    if not zipfile.is_zipfile(fname):
        os.remove(fname)
        return "Not a valid zip archive."

    zip = zipfile.ZipFile(fname)
    required_suffixes = [".shp", ".shx", ".dbf", ".prj"]
    has_suffix = {}

    for suffix in required_suffixes:
        has_suffix[suffix] = False

    for info in zip.infolist():
        suffix = os.path.splitext(info.filename)[1].lower()
        if suffix in required_suffixes:
            has_suffix[suffix] = True

    for suffix in required_suffixes:
        if not has_suffix[suffix]:
            zip.close()
            os.remove(fname)
            return "Archive missing required " + suffix + " file."

    shapefile_name = None
    dir_name = tempfile.mkdtemp()
    for info in zip.infolist():
        if (info.filename.endswith(".shp") == True):
            shapefile_name = info.filename
        dst_file = os.path.join(dir_name, info.filename)
        f = open(dst_file, "wb")
        f.write(zip.read(info.filename))
        f.close()
    zip.close()

    try:
        datasource = ogr.Open(os.path.join(dir_name, shapefile_name))
        layer = datasource.GetLayer(0)
        ds = DataSource(os.path.join(dir_name, shapefile_name))
        lyr = ds[0]
        shapefile_ok = True
    except:
        traceback.print_exc()
        shapefile_ok = False
    if not shapefile_ok:
        os.remove(fname)
        shutil.rmtree(dir_name)
        return "Not a valid shapefile."

    src_spatial_ref = layer.GetSpatialRef()
    print(src_spatial_ref)
    geom_type = layer.GetLayerDefn().GetGeomType()
    geom_name = ogr.GeometryTypeToName(geom_type)
    shapefile = Shapefile(filename=shapefile_name,
                          srs_wkt=src_spatial_ref.ExportToWkt(),
                          geom_type=geom_name)
    shapefile.save()

    attributes = []
    layer_def = layer.GetLayerDefn()
    for i in range(layer_def.GetFieldCount()):
        field_def = layer_def.GetFieldDefn(i)
        attr = Attribute(shapefile=shapefile,
                         name=field_def.GetName(),
                         type=field_def.GetType(),
                         width=field_def.GetWidth(),
                         precision=field_def.GetPrecision())
        attr.save()
        attributes.append(attr)

    dst_spatial_ref = osr.SpatialReference()
    dst_spatial_ref.ImportFromEPSG(4326)
    coord_transform = osr.CoordinateTransformation(src_spatial_ref,
                                                   dst_spatial_ref)

    for i in range(layer.GetFeatureCount()):
        src_feature = layer.GetFeature(i)
        src_geometry = src_feature.GetGeometryRef()
        # src_geometry.Transform(coord_transform)
        geometry = GEOSGeometry(src_geometry.ExportToWkt())
        geometry = utils.wrap_geos_geometry(geometry)
        geom_field = utils.calc_geometry_field(geom_name)
        fields = {}
        fields['shapefile'] = shapefile
        fields['name'] = 'GAPA_NAPA'
        fields[geom_field] = geometry
        feature = Feature(**fields)
        feature.save()

    for attr in attributes:
        success, result = utils.get_ogr_feature_attribute(attr, src_feature)
        if not success:
            os.remove(fname)
            shutil.rmtree(dir_name)
            shapefile.delete()
            return result
        attr_value = AttributeValue(feature=feature,
                                    attribute=attr,
                                    value=result)
        attr_value.save()

    os.remove(fname)
    shutil.rmtree(dir_name, ignore_errors=True, onerror=None)
    return None
예제 #19
0
def ogr_source_to_csv(source_definition, source_path, dest_path):
    "Convert a single shapefile or GeoJSON in source_path and put it in dest_path"
    in_datasource = ogr.Open(source_path, 0)
    in_layer = in_datasource.GetLayer()
    inSpatialRef = in_layer.GetSpatialRef()

    _L.info("Converting a layer to CSV: %s", in_layer.GetName())

    # Determine the appropriate SRS
    if inSpatialRef is None:
        # OGR couldn't find the projection, let's hope there's an SRS tag.
        _L.info("No projection file found for source %s", source_path)
        srs = source_definition["conform"].get("srs", None)
        if srs is not None and srs.startswith(u"EPSG:"):
            _L.debug("SRS tag found specifying %s", srs)
            inSpatialRef = osr.SpatialReference()
            inSpatialRef.ImportFromEPSG(int(srs[5:]))
        else:
            # OGR is capable of doing more than EPSG, but so far we don't need it.
            raise Exception("Bad SRS. Can only handle EPSG, the SRS tag is %s",
                            srs)

    # Determine the appropriate text encoding. This is complicated in OGR, see
    # https://github.com/openaddresses/machine/issues/42
    if in_layer.TestCapability(ogr.OLCStringsAsUTF8):
        # OGR turned this to UTF 8 for us
        shp_encoding = 'utf-8'
    elif "encoding" in source_definition["conform"]:
        shp_encoding = source_definition["conform"]["encoding"]
    else:
        _L.warn(
            "No encoding given and OGR couldn't guess. Trying ISO-8859-1, YOLO!"
        )
        shp_encoding = "iso-8859-1"
    _L.debug("Assuming shapefile data is encoded %s", shp_encoding)

    # Get the input schema, create an output schema
    in_layer_defn = in_layer.GetLayerDefn()
    out_fieldnames = []
    for i in range(0, in_layer_defn.GetFieldCount()):
        field_defn = in_layer_defn.GetFieldDefn(i)
        out_fieldnames.append(field_defn.GetName())
    out_fieldnames.append(X_FIELDNAME)
    out_fieldnames.append(Y_FIELDNAME)

    # Set up a transformation from the source SRS to EPSG:4326
    outSpatialRef = osr.SpatialReference()
    outSpatialRef.ImportFromEPSG(4326)
    coordTransform = osr.CoordinateTransformation(inSpatialRef, outSpatialRef)

    # Write a CSV file with one row per feature in the OGR source
    with csvopen(dest_path, 'w', encoding='utf-8') as f:
        writer = csvDictWriter(f, fieldnames=out_fieldnames, encoding='utf-8')
        writer.writeheader()

        in_feature = in_layer.GetNextFeature()
        while in_feature:
            row = dict()

            for i in range(0, in_layer_defn.GetFieldCount()):
                field_defn = in_layer_defn.GetFieldDefn(i)
                field_value = in_feature.GetField(i)
                if isinstance(field_value, str):
                    # Convert OGR's byte sequence strings to Python Unicode strings
                    field_value = field_value.decode(shp_encoding) \
                        if hasattr(field_value, 'decode') else field_value
                row[field_defn.GetNameRef()] = field_value
            geom = in_feature.GetGeometryRef()
            if geom is not None:
                geom.Transform(coordTransform)
                # Calculate the centroid of the geometry and write it as X and Y columns
                try:
                    centroid = geom.Centroid()
                except RuntimeError as e:
                    if 'Invalid number of points in LinearRing found' not in str(
                            e):
                        raise
                    xmin, xmax, ymin, ymax = geom.GetEnvelope()
                    row[X_FIELDNAME] = xmin / 2 + xmax / 2
                    row[Y_FIELDNAME] = ymin / 2 + ymax / 2
                else:
                    row[X_FIELDNAME] = centroid.GetX()
                    row[Y_FIELDNAME] = centroid.GetY()
            else:
                row[X_FIELDNAME] = None
                row[Y_FIELDNAME] = None

            writer.writerow(row)

            in_feature.Destroy()
            in_feature = in_layer.GetNextFeature()

    in_datasource.Destroy()
예제 #20
0
from osgeo import osr
from osgeo import gdal

DATA_PATH = "/Users/macbookair/PycharmProjects/helloworld/DATA/vector/"
fic = DATA_PATH + "miami/miami.shp"

# Définition de la projection source
srcProjection = osr.SpatialReference()
srcProjection.SetUTM(17)

# Définition de la projection de destination
dstProjection = osr.SpatialReference()
dstProjection.SetWellKnownGeogCS('WGS84')  # Lat/long.

# Définition de la fonction de transformtion
transform = osr.CoordinateTransformation(srcProjection, dstProjection)

# Open the source shapefile.
srcFile = ogr.Open(fic)
srcLayer = srcFile.GetLayer(0)

# Creation du shapefile avec son systeme de projection
if os.path.exists("miami-reprojected"):
    shutil.rmtree("miami-reprojected")

os.mkdir("miami-reprojected")

driver = ogr.GetDriverByName("ESRI Shapefile")
dstPath = os.path.join("miami-reprojected", "miami.shp")
dstFile = driver.CreateDataSource(dstPath)
dstLayer = dstFile.CreateLayer("layer", dstProjection)
예제 #21
0
def projectShpfileIntoXY(workDir, file0, inDirFilename, fn, typeOfGeom):
	# set the working directory
	#workDir = "E:\\Documents\\NutrientsLecture2\\Maps"
	os.chdir(workDir)
	 
	# get the shapefile driver
	driver = ogr.GetDriverByName('ESRI Shapefile')

	# create the input SpatialReference
	inSpatialRef = osr.SpatialReference()
	inSpatialRef.ImportFromEPSG(4269)

	# Opening 
	#file0 = "E:\\Red_deer_SPARROW\\RiverNet2\\CatchmentDef.shp"
	shfileCatch0, layer0 = openingShpFile(file0)
	# - Getting the spatial projection
	#geoSRlayer0 = layer0.GetSpatialRef()
	geoSR = layer0.GetSpatialRef()
	wkt = geoSR.ExportToWkt()
	print wkt# create the output SpatialReference
	outSpatialRef = osr.SpatialReference()
	outSpatialRef.ImportFromWkt(wkt)
	#geoSRop.ImportFromWkt(demWKT)

	# create the CoordinateTransformation
	coordTrans = osr.CoordinateTransformation(inSpatialRef, outSpatialRef)

	# open the input data source and get the layer
	#inDirFilename = r'E:\Documents\NutrientsLecture2\Maps\Catchment.shp'
	inDS = driver.Open(inDirFilename, 0)
	if inDS is None:
	  print 'Could not open file'
	  sys.exit(1)
	inLayer = inDS.GetLayer()

	# create a new data source and layer
	#fn = 'NLFLOW_1geog_MiryCreekV2_proj.shp'
	#fn = 'Catchment_proj.shp'
	if os.path.exists(fn):
	  driver.DeleteDataSource(fn)
	outDS = driver.CreateDataSource(fn)
	if outDS is None:
	  print 'Could not create file'
	  sys.exit(1)
	#outLayer = outDS.CreateLayer('NLFLOW_1geog_MiryCreekV2_proj', outSpatialRef, geom_type=ogr.wkbLineString)
	if typeOfGeom == 'point':
		outLayer = outDS.CreateLayer(fn[:-4], outSpatialRef, geom_type=ogr.wkbPoint)
	elif typeOfGeom == 'line':
		outLayer = outDS.CreateLayer(fn[:-4], outSpatialRef, geom_type=ogr.wkbLineString)
	elif typeOfGeom == 'polygon':
		outLayer = outDS.CreateLayer(fn[:-4], outSpatialRef, geom_type=ogr.wkbPolygon)
	else:
		print 'Could not project file'
		sys.exit(1)
	#outLayer = outDS.CreateLayer(fn[:-4], outSpatialRef, geom_type=ogr.wkbPolygon)


	# Getting the fields of the features
	layer_defn = inLayer.GetLayerDefn() #get definitions of the layer
	field_names = [layer_defn.GetFieldDefn(i).GetName() for i in range(layer_defn.GetFieldCount())] #store the field names as a list of strings


	# use the input FieldDefn to add a field to the output
	for fieldname in field_names:
		fieldDefn = inLayer.GetFeature(0).GetFieldDefnRef(fieldname)
		outLayer.CreateField(fieldDefn)

	# # get the FieldDefn for the county name field
	# feature = inLayer.GetFeature(0)
	# fieldDefn = feature.GetFieldDefnRef('NID')

	# # add the field to the output shapefile
	# outLayer.CreateField(fieldDefn)

	# get the FeatureDefn for the output shapefile
	featureDefn = outLayer.GetLayerDefn()

	# loop through the input features
	inFeature = inLayer.GetNextFeature()
	k = 0
	while inFeature:
	
	  print 'Projection into XY coord feature No.: ', k

	  # get the input geometry
	  geom = inFeature.GetGeometryRef()
	  #print geom.GetGeometryName() # Getting the type of geometry

	  # reproject the geometry
	  geom.Transform(coordTrans)

	  # create a new feature
	  outFeature = ogr.Feature(featureDefn)
	 
	  # set the geometry and attribute
	  outFeature.SetGeometry(geom)
	 
	  # Set attribute 
	  for fieldname in field_names:
		outFeature.SetField(fieldname, inFeature.GetField(fieldname))

	  #outFeature.SetField('NID', inFeature.GetField('NID'))

	  # add the feature to the shapefile
	  outLayer.CreateFeature(outFeature)

	  # destroy the features and get the next input feature
	  outFeature.Destroy
	  inFeature.Destroy
	  inFeature = inLayer.GetNextFeature()
	  
	  k += 1

	# Close the shapefiles
	inDS.Destroy()
	outDS.Destroy()

	# create the *.prj file
	outSpatialRef.MorphToESRI()
	#open('redDeerRiverNHN_proj.prj', 'w')
	file = open(fn[:-4]+'.prj','w')#open('redDeerRiverNHN_proj.prj', 'w')
	file.write(outSpatialRef.ExportToWkt())
	file.close()
예제 #22
0
def xyz_parse(src_xyz, xyz_c=_xyz_config, region=None, verbose=False):
    """xyz file parsing generator

    Args:
      src_xyz (generataor): list/generator of xyz data
      xyz_c (dict): xyz config dictionary
      region (list): a `region` list [xmin, xmax, ymin, ymax]
      verbose (bool): increase verbosity

    Yields:
      list: xyz data [x, y, z, ...]
    """

    ln = 0
    pass_d = True
    skip = int(xyz_c['skip'])

    if xyz_c['epsg'] == xyz_c['warp'] or xyz_c['epsg'] is None:
        xyz_c['warp'] = None

    if xyz_c['warp'] is not None:
        src_srs = osr.SpatialReference()
        src_srs.ImportFromEPSG(int(xyz_c['epsg']))
        dst_srs = osr.SpatialReference()
        dst_srs.ImportFromEPSG(int(xyz_c['warp']))

        try:
            src_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
            dst_srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
        except:
            pass

        dst_trans = osr.CoordinateTransformation(src_srs, dst_srs)

    else:
        src_srs = dst_srs = dst_trans = None

    for xyz in src_xyz:
        pass_d = True

        if ln >= skip:
            this_xyz = xyz_parse_line(xyz, xyz_c)

            if this_xyz is not None:
                if xyz_c['warp'] is not None:
                    this_xyz = xyz_warp(this_xyz, dst_trans)

                if region is not None:
                    if regions.region_valid_p:
                        if not xyz_in_region_p(this_xyz, region):
                            pass_d = False

                if xyz_c['upper_limit'] is not None or xyz_c[
                        'lower_limit'] is not None:
                    if not regions.z_pass(this_xyz[2],
                                          upper_limit=xyz_c['upper_limit'],
                                          lower_limit=xyz_c['lower_limit']):
                        pass_d = False

            else:
                pass_d = False

            if pass_d:
                ln += 1
                yield (this_xyz)

        else:
            skip -= 1

    if verbose:
        if ln == 0:
            status = -1
        else:
            status = 0

        utils.echo_msg('parsed {} data records from {}'.format(
            ln, xyz_c['name']))
예제 #23
0
if substepsize > stepsize:
    substepsize = stepsize

# -
# Do we have an alternate SRS?

ct = None

if t_srs is not None:
    t_srs_o = osr.SpatialReference()
    t_srs_o.SetFromUserInput(t_srs)

    s_srs_o = osr.SpatialReference()
    s_srs_o.SetFromUserInput('WGS84')

    ct = osr.CoordinateTransformation(s_srs_o, t_srs_o)
else:
    t_srs_o = osr.SpatialReference()
    t_srs_o.SetFromUserInput('WGS84')

# -
# Create graticule file.

drv = ogr.GetDriverByName('ESRI Shapefile')

try:
    drv.DeleteDataSource(outfile)
except:
    pass

ds = drv.CreateDataSource(outfile)
예제 #24
0
def main():

    ### Read input arguments #####
    logfilename = 'wtools_static_maps.log'
    parser = OptionParser()
    usage = "usage: %prog [options]"
    parser = OptionParser(usage=usage)
    parser.add_option('-q', '--quiet',
                      dest='verbose', default=True, action='store_false',
                      help='do not print status messages to stdout')
    parser.add_option('-i', '--ini', dest='inifile', default=None,
                      help='ini file with settings for static_maps.exe')
    parser.add_option('-s', '--source',
                      dest='source', default='wflow',
                      help='Source folder containing clone (default=./wflow)')
    parser.add_option('-d', '--destination',
                      dest='destination', default='staticmaps',
                      help='Destination folder (default=./staticmaps)')
    parser.add_option('-r', '--river',
                      dest='rivshp', default=None,
                      help='river network polyline layer (ESRI Shapefile)')
    parser.add_option('-c', '--catchment',
                      dest='catchshp', default=None,
                      help='catchment polygon layer (ESRI Shapefile)')
    parser.add_option('-g', '--gauges',
                      dest='gaugeshp', default=None,
                      help='gauge point layer (ESRI Shapefile)')
    parser.add_option('-D', '--dem',
                      dest='dem_in', default=None,
                      help='digital elevation model (GeoTiff)')
    parser.add_option('-L', '--landuse',
                      dest='landuse', default=None,
                      help='land use / land cover layer (GeoTiff)')
    parser.add_option('-S', '--soiltype',
                      dest='soil', default=None,
                      help='soil type layer (GeoTiff)')
    parser.add_option('-V', '--vegetation',
                      dest='lai', default=None,
                      help='vegetation LAI layer location (containing 12 GeoTiffs <LAI00000.XXX.tif>)')
    parser.add_option('-O', '--other_maps',
                      dest='other_maps', default=None,
                      help='bracketed [] comma-separated list of paths to other maps that should be reprojected')
    parser.add_option('-C', '--clean',
                      dest='clean', default=False, action='store_true',
                      help='Clean the .xml files from static maps folder when finished')
    parser.add_option('-A', '--alltouch',
                      dest='alltouch', default=False, action='store_true',
                      help='option to burn catchments "all touching".\nUseful when catchment-size is small compared to cellsize')
    (options, args) = parser.parse_args()
    # parse other maps into an array
    options.other_maps = options.other_maps.replace(' ', '').replace('[', '').replace(']', '').split(',')

    options.source = os.path.abspath(options.source)
    clone_map = os.path.join(options.source, 'mask.map')
    clone_shp = os.path.join(options.source, 'mask.shp')
    clone_prj = os.path.join(options.source, 'mask.prj')
    
    if None in (options.inifile,
                options.rivshp,
                options.catchshp,
                options.dem_in):
        msg = """The following files are compulsory:
        - ini file
        - DEM (raster)
        - river (shape)
        - catchment (shape)
        """
        print(msg)
        parser.print_help()
        sys.exit(1)
    if not os.path.exists(options.inifile):
        print 'path to ini file cannot be found'
        sys.exit(1)
    if not os.path.exists(options.rivshp):
        print 'path to river shape cannot be found'
        sys.exit(1)
    if not os.path.exists(options.catchshp):
        print 'path to catchment shape cannot be found'
        sys.exit(1)
    if not os.path.exists(options.dem_in):
        print 'path to DEM cannot be found'
        sys.exit(1)    
        
    
    # open a logger, dependent on verbose print to screen or not
    logger, ch = wtools_lib.setlogger(logfilename, 'WTOOLS', options.verbose)

    # create directories # TODO: check if workdir is still necessary, try to keep in memory as much as possible

    # delete old files (when the source and destination folder are different)
    if np.logical_and(os.path.isdir(options.destination),
                      options.destination is not options.source):
        shutil.rmtree(options.destination)
    if options.destination is not options.source:
        os.makedirs(options.destination)

    # Read mask
    if not(os.path.exists(clone_map)):
        logger.error('Clone file {:s} not found. Please run create_grid first.'.format(clone_map))
        sys.exit(1)
    else:
        # set clone
        pcr.setclone(clone_map)
        # get the extent from clone.tif
        xax, yax, clone, fill_value = gis.gdal_readmap(clone_map, 'GTiff')
        trans = wtools_lib.get_geotransform(clone_map)
        extent = wtools_lib.get_extent(clone_map)
        xmin, ymin, xmax, ymax = extent
        zeros = np.zeros(clone.shape)
        ones = pcr.numpy2pcr(pcr.Scalar, np.ones(clone.shape), -9999)
        # get the projection from clone.tif
        srs = wtools_lib.get_projection(clone_map)
        unit_clone = srs.GetAttrValue('UNIT').lower()

    ### READ CONFIG FILE
    # open config-file
    config=wtools_lib.OpenConf(options.inifile)
    
    # read settings
    snapgaugestoriver = wtools_lib.configget(config, 'settings',
                                             'snapgaugestoriver',
                                              True, datatype='boolean')
    burnalltouching = wtools_lib.configget(config, 'settings',
                                           'burncatchalltouching',
                                            True, datatype='boolean')
    burninorder = wtools_lib.configget(config, 'settings',
                                       'burncatchalltouching',
                                       False, datatype='boolean')
    verticetollerance = wtools_lib.configget(config, 'settings',
                                             'vertice_tollerance',
                                             0.0001, datatype='float')
    
    ''' read parameters '''
    burn_outlets = wtools_lib.configget(config, 'parameters',
                                        'burn_outlets', 10000,
                                        datatype='int')
    burn_rivers = wtools_lib.configget(config, 'parameters',
                                       'burn_rivers', 200,
                                       datatype='int')
    burn_connections = wtools_lib.configget(config, 'parameters',
                                            'burn_connections', 100,
                                            datatype='int')
    burn_gauges = wtools_lib.configget(config, 'parameters',
                                       'burn_gauges', 100,
                                       datatype='int')
    minorder = wtools_lib.configget(config, 'parameters',
                                    'riverorder_min', 3,
                                    datatype='int')
    percentiles = np.array(
        config.get('parameters', 'statisticmaps', '0, 100').replace(
            ' ', '').split(','), dtype='float')
            
    # read the parameters for generating a temporary very high resolution grid
    if unit_clone == 'degree':
       cellsize_hr = wtools_lib.configget(config, 'parameters',
                                          'highres_degree', 0.0005,
                                          datatype='float')
    elif (unit_clone == 'metre') or (unit_clone == 'meter'):
       cellsize_hr = wtools_lib.configget(config, 'parameters',
                                          'highres_metre', 50,
                                          datatype='float') 
    
    cols_hr = int((float(xmax)-float(xmin))/cellsize_hr + 2)
    rows_hr = int((float(ymax)-float(ymin))/cellsize_hr + 2)
    hr_trans = (float(xmin), cellsize_hr, float(0),
                float(ymax), 0, -cellsize_hr)
    clone_hr = os.path.join(options.destination, 'clone_highres.tif')
    # make a highres clone as well!
    wtools_lib.CreateTif(clone_hr, rows_hr, cols_hr, hr_trans, srs, 0)

    # read staticmap locations
    catchment_map = wtools_lib.configget(config, 'staticmaps',
                                         'catchment', 'wflow_catchment.map')
    dem_map = wtools_lib.configget(config, 'staticmaps',
                                   'dem', 'wflow_dem.map')
    demmax_map = wtools_lib.configget(config, 'staticmaps',
                                      'demmax', 'wflow_demmax.map')
    demmin_map = wtools_lib.configget(config, 'staticmaps',
                                      'demmin', 'wflow_demmin.map')
    gauges_map = wtools_lib.configget(config, 'staticmaps',
                                      'gauges', 'wflow_gauges.map')
    landuse_map = wtools_lib.configget(config, 'staticmaps',
                                       'landuse', 'wflow_landuse.map')
    ldd_map = wtools_lib.configget(config, 'staticmaps',
                                   'ldd', 'wflow_ldd.map')
    river_map = wtools_lib.configget(config, 'staticmaps',
                                     'river', 'wflow_river.map')
    outlet_map = wtools_lib.configget(config, 'staticmaps',
                                      'outlet', 'wflow_outlet.map')
    riverlength_fact_map = wtools_lib.configget(config, 'staticmaps',
                                                'riverlength_fact',
                                                'wflow_riverlength_fact.map')
    soil_map = wtools_lib.configget(config, 'staticmaps',
                                    'soil', 'wflow_soil.map')
    streamorder_map = wtools_lib.configget(config, 'staticmaps',
                                           'streamorder',
                                           'wflow_streamorder.map')
    subcatch_map = wtools_lib.configget(config, 'staticmaps',
                                        'subcatch', 'wflow_subcatch.map')

    # read mask location (optional)
    masklayer = wtools_lib.configget(config, 'mask', 'masklayer', options.catchshp)


    # ???? empty = pcr.ifthen(ones == 0, pcr.scalar(0))

    # TODO: check if extents are correct this way
    # TODO: check what the role of missing values is in zeros and ones (l. 123 in old code)

    # first add a missing value to dem_in
    ds = gdal.Open(options.dem_in, gdal.GA_Update)
    RasterBand = ds.GetRasterBand(1)
    fill_val = RasterBand.GetNoDataValue()

    if fill_val is None:
        RasterBand.SetNoDataValue(-9999)
    ds = None
    
    # reproject to clone map: see http://stackoverflow.com/questions/10454316/how-to-project-and-resample-a-grid-to-match-another-grid-with-gdal-python
    # resample DEM
    logger.info('Resampling dem from {:s} to {:s}'.format(os.path.abspath(options.dem_in), os.path.join(options.destination, dem_map)))
    gis.gdal_warp(options.dem_in, clone_map, os.path.join(options.destination, dem_map), format='PCRaster', gdal_interp=gdalconst.GRA_Average)
    # retrieve amount of rows and columns from clone
    # TODO: make windowstats applicable to source/target with different projections. This does not work yet.
    # retrieve srs from DEM
    try:
        srs_dem = wtools_lib.get_projection(options.dem_in)
    except:
        logger.warning('No projection found in DEM, assuming WGS 1984 lat long')
        srs_dem = osr.SpatialReference()
        srs_dem.ImportFromEPSG(4326)
    clone2dem_transform = osr.CoordinateTransformation(srs,srs_dem)
    #if srs.ExportToProj4() == srs_dem.ExportToProj4():
    for percentile in percentiles:
        if percentile >= 100:
            logger.info('computing window maximum')
            percentile_dem = os.path.join(options.destination, 'wflow_dem_max.map')
        elif percentile <= 0:
            logger.info('computing window minimum')
            percentile_dem = os.path.join(options.destination, 'wflow_dem_min.map')
        else:
            logger.info('computing window {:d} percentile'.format(int(percentile)))
            percentile_dem = os.path.join(options.destination, 'wflow_dem_{:03d}.map'.format(int(percentile)))

        percentile_dem = os.path.join(options.destination, 'wflow_dem_{:03d}.map'.format(int(percentile)))
        stats = wtools_lib.windowstats(options.dem_in, len(yax), len(xax),
                               trans, srs, percentile_dem, percentile, transform=clone2dem_transform,logger=logger)
#    else:
#        logger.warning('Projections of DEM and clone are different. DEM statistics for different projections is not yet implemented')

    """

    # burn in rivers
    # first convert and clip the river shapefile
    # retrieve river shape projection, if not available assume EPSG:4326
    file_att = os.path.splitext(os.path.basename(options.rivshp))[0]
    ds = ogr.Open(options.rivshp)
    lyr = ds.GetLayerByName(file_att)
    extent = lyr.GetExtent()
    extent_in = [extent[0], extent[2], extent[1], extent[3]]
    try:
        # get spatial reference from shapefile
        srs_rivshp = lyr.GetSpatialRef()
        logger.info('Projection in river shapefile is {:s}'.format(srs_rivshp.ExportToProj4()))
    except:
        logger.warning('No projection found in {:s}, assuming WGS 1984 lat-lon'.format(options.rivshp))
        srs_rivshp = osr.SpatialReference()
        srs_rivshp.ImportFromEPSG(4326)
    rivprojshp = os.path.join(options.destination, 'rivshp_proj.shp')
    logger.info('Projecting and clipping {:s} to {:s}'.format(options.rivshp, rivprojshp))
    # TODO: Line below takes a very long time to process, the bigger the shapefile, the more time. How do we deal with this?
    call(('ogr2ogr','-s_srs', srs_rivshp.ExportToProj4(),'-t_srs', srs.ExportToProj4(), '-clipsrc', '{:f}'.format(xmin), '{:f}'.format(ymin), '{:f}'.format(xmax), '{:f}'.format(ymax), rivprojshp, options.rivshp))
    """

    # TODO: BURNING!!


    # project catchment layer to projection of clone
    file_att = os.path.splitext(os.path.basename(options.catchshp))[0]
    print options.catchshp
    ds = ogr.Open(options.catchshp)
    lyr = ds.GetLayerByName(file_att)
    extent = lyr.GetExtent()
    extent_in = [extent[0], extent[2], extent[1], extent[3]]
    try:
        # get spatial reference from shapefile
        srs_catchshp = lyr.GetSpatialRef()
        logger.info('Projection in catchment shapefile is {:s}'.format(srs_catchshp.ExportToProj4()))
    except:
        logger.warning('No projection found in {:s}, assuming WGS 1984 lat-lon'.format(options.catchshp))
        srs_catchshp = osr.SpatialReference()
        srs_catchshp.ImportFromEPSG(4326)
    catchprojshp = os.path.join(options.destination, 'catchshp_proj.shp')
    logger.info('Projecting {:s} to {:s}'.format(options.catchshp, catchprojshp))
    call(('ogr2ogr','-s_srs', srs_catchshp.ExportToProj4(),'-t_srs', srs.ExportToProj4(), '-clipsrc', '{:f}'.format(xmin), '{:f}'.format(ymin), '{:f}'.format(xmax), '{:f}'.format(ymax), catchprojshp, options.catchshp))

    #
    logger.info('Calculating ldd')
    ldddem = pcr.readmap(os.path.join(options.destination, dem_map))
    ldd_select=pcr.lddcreate(ldddem, 1e35, 1e35, 1e35, 1e35)
    pcr.report(ldd_select, os.path.join(options.destination, 'wflow_ldd.map'))

    # compute stream order, identify river cells
    streamorder = pcr.ordinal(pcr.streamorder(ldd_select))
    river = pcr.ifthen(streamorder >= pcr.ordinal(minorder), pcr.boolean(1))
    # find the minimum value in the DEM and cover missing values with a river with this value. Effect is none!! so now left out!
    # mindem = int(np.min(pcr.pcr2numpy(pcr.ordinal(os.path.join(options.destination, dem_map)),9999999)))
    # dem_resample_map = pcr.cover(os.path.join(options.destination, dem_map), pcr.scalar(river)*0+mindem)
    # pcr.report(dem_resample_map, os.path.join(options.destination, dem_map))
    pcr.report(streamorder, os.path.join(options.destination, streamorder_map))
    pcr.report(river, os.path.join(options.destination, river_map))

    # deal with your catchments
    if options.gaugeshp == None:
        logger.info('No gauges defined, using outlets instead')
        gauges = pcr.ordinal(
            pcr.uniqueid(
                pcr.boolean(
                    pcr.ifthen(pcr.scalar(ldd_select)==5,
                               pcr.boolean(1)
                               )
                )
            )
        )
        pcr.report(gauges, os.path.join(options.destination, gauges_map))
    # TODO: Add the gauge shape code from StaticMaps.py (line 454-489)
    # TODO: add river length map (see SticMaps.py, line 492-499)

    # report river length
    # make a high resolution empty map
    dem_hr_file = os.path.join(options.destination, 'dem_highres.tif')
    burn_hr_file = os.path.join(options.destination, 'burn_highres.tif')
    demburn_hr_file = os.path.join(options.destination, 'demburn_highres.map')
    riv_hr_file = os.path.join(options.destination, 'riv_highres.map')
    gis.gdal_warp(options.dem_in, clone_hr, dem_hr_file)
    # wtools_lib.CreateTif(riv_hr, rows_hr, cols_hr, hr_trans, srs, 0)
    file_att = os.path.splitext(os.path.basename(options.rivshp))[0]
    # open the shape layer
    ds = ogr.Open(options.rivshp)
    lyr = ds.GetLayerByName(file_att)
    gis.ogr_burn(lyr, clone_hr, -100, file_out=burn_hr_file,
                  format='GTiff', gdal_type=gdal.GDT_Float32, fill_value=0)
    # read dem and burn values and add
    xax_hr, yax_hr, burn_hr, fill = gis.gdal_readmap(burn_hr_file, 'GTiff')
    burn_hr[burn_hr==fill] = 0
    xax_hr, yax_hr, dem_hr, fill = gis.gdal_readmap(dem_hr_file, 'GTiff')
    dem_hr[dem_hr==fill] = np.nan
    demburn_hr = dem_hr + burn_hr
    demburn_hr[np.isnan(demburn_hr)] = -9999
    gis.gdal_writemap(demburn_hr_file, 'PCRaster', xax_hr, yax_hr, demburn_hr, -9999.)
    pcr.setclone(demburn_hr_file)
    demburn_hr = pcr.readmap(demburn_hr_file)
    ldd_hr = pcr.lddcreate(demburn_hr, 1e35, 1e35, 1e35, 1e35)
    pcr.report(ldd_hr, os.path.join(options.destination, 'ldd_hr.map'))
    pcr.setglobaloption('unitcell')
    riv_hr = pcr.scalar(pcr.streamorder(ldd_hr) >= minorder)*pcr.downstreamdist(ldd_hr)
    pcr.report(riv_hr, riv_hr_file)
    pcr.setglobaloption('unittrue')
    pcr.setclone(clone_map)
    logger.info('Computing river length')
    #riverlength = wt.windowstats(riv_hr,clone_rows,clone_columns,clone_trans,srs_clone,resultdir,'frac',clone2dem_transform)
    riverlength = wtools_lib.windowstats(riv_hr_file, len(yax), len(xax),
                                 trans, srs, os.path.join(options.destination, riverlength_fact_map), stat='fact', logger=logger)
    # TODO: nothing happends with the river lengths yet. Need to decide how to use these

    # report outlet map
    pcr.report(pcr.ifthen(pcr.ordinal(ldd_select)==5, pcr.ordinal(1)), os.path.join(options.destination, outlet_map))

    # report subcatchment map
    subcatchment = pcr.subcatchment(ldd_select, gauges)
    pcr.report(pcr.ordinal(subcatchment), os.path.join(options.destination, subcatch_map))

    # Report land use map
    if options.landuse == None:
        logger.info('No land use map used. Preparing {:s} with only ones.'.
                    format(os.path.join(options.destination, landuse_map)))
        pcr.report(pcr.nominal(ones), os.path.join(options.destination, landuse_map))
    else:
        logger.info('Resampling land use from {:s} to {:s}'.
                    format(os.path.abspath(options.landuse),
                           os.path.join(options.destination, os.path.abspath(landuse_map))))
        gis.gdal_warp(options.landuse,
                      clone_map,
                      os.path.join(options.destination, landuse_map),
                      format='PCRaster',
                      gdal_interp=gdalconst.GRA_Mode,
                      gdal_type=gdalconst.GDT_Int32)

    # report soil map
    if options.soil == None:
        logger.info('No soil map used. Preparing {:s} with only ones.'.
                    format(os.path.join(options.destination, soil_map)))
        pcr.report(pcr.nominal(ones), os.path.join(options.destination, soil_map))
    else:
        logger.info('Resampling soil from {:s} to {:s}'.
                    format(os.path.abspath(options.soil),
                           os.path.join(options.destination, os.path.abspath(soil_map))))
        gis.gdal_warp(options.soil,
                      clone_map,
                      os.path.join(options.destination, soil_map),
                      format='PCRaster',
                      gdal_interp=gdalconst.GRA_Mode,
                      gdal_type=gdalconst.GDT_Int32)

    if options.lai == None:
        logger.info('No vegetation LAI maps used. Preparing default maps {:s} with only ones.'.
                    format(os.path.join(options.destination, soil_map)))
        pcr.report(pcr.nominal(ones), os.path.join(options.destination, soil_map))
    else:
        dest_lai = os.path.join(options.destination, 'clim')
        os.makedirs(dest_lai)
        for month in range(12):
            lai_in = os.path.join(options.lai, 'LAI00000.{:03d}'.format(month + 1))
            lai_out = os.path.join(dest_lai, 'LAI00000.{:03d}'.format(month + 1))
            logger.info('Resampling vegetation LAI from {:s} to {:s}'.
                        format(os.path.abspath(lai_in),
                               os.path.abspath(lai_out)))
            gis.gdal_warp(lai_in,
                          clone_map,
                          lai_out,
                          format='PCRaster',
                          gdal_interp=gdalconst.GRA_Bilinear,
                          gdal_type=gdalconst.GDT_Float32)

    # report soil map
    if options.other_maps == None:
        logger.info('No other maps used. Skipping other maps.')
    else:
        logger.info('Resampling list of other maps...')
        for map_file in options.other_maps:
            map_name = os.path.split(map_file)[1]
            logger.info('Resampling a map from {:s} to {:s}'.
                        format(os.path.abspath(map_file),
                               os.path.join(options.destination, map_name)))
            gis.gdal_warp(map_file,
                          clone_map,
                          os.path.join(options.destination, map_name),
                          format='PCRaster',
                          gdal_interp=gdalconst.GRA_Mode,
                          gdal_type=gdalconst.GDT_Float32)


    if options.clean:
        wtools_lib.DeleteList(glob.glob(os.path.join(options.destination, '*.xml')),
                              logger=logger)
        wtools_lib.DeleteList(glob.glob(os.path.join(options.destination, 'clim', '*.xml')),
                              logger=logger)
        wtools_lib.DeleteList(glob.glob(os.path.join(options.destination, '*highres*')),
                              logger=logger)
예제 #25
0
def parse_shp(shp_file_path):
    """
    :param shp_file_path: full file path fo the .shp file

    output dictionary format
    shp_metadata_dict["origin_projection_string"]: original projection string
    shp_metadata_dict["origin_projection_name"]: origin_projection_name
    shp_metadata_dict["origin_datum"]: origin_datum
    shp_metadata_dict["origin_unit"]: origin_unit
    shp_metadata_dict["field_meta_dict"]["field_list"]: list [fieldname1, fieldname2...]
    shp_metadata_dict["field_meta_dict"]["field_attr_dic"]:
       dict {"fieldname": dict {
                             "fieldName":fieldName,
                             "fieldTypeCode":fieldTypeCode,
                             "fieldType":fieldType,
                             "fieldWidth:fieldWidth,
                             "fieldPrecision:fieldPrecision"
                              }
             }
    shp_metadata_dict["feature_count"]: feature count
    shp_metadata_dict["geometry_type"]: geometry_type
    shp_metadata_dict["origin_extent_dict"]:
    dict{"west": east, "north":north, "east":east, "south":south}
    shp_metadata_dict["wgs84_extent_dict"]:
    dict{"west": east, "north":north, "east":east, "south":south}
    """

    shp_metadata_dict = {}
    # read shapefile
    driver = ogr.GetDriverByName('ESRI Shapefile')
    dataset = driver.Open(shp_file_path)

    # get layer
    layer = dataset.GetLayer()
    # get spatialRef from layer
    spatialRef_from_layer = layer.GetSpatialRef()

    if spatialRef_from_layer is not None:
        shp_metadata_dict["origin_projection_string"] = str(
            spatialRef_from_layer)
        prj_name = spatialRef_from_layer.GetAttrValue('projcs')
        if prj_name is None:
            prj_name = spatialRef_from_layer.GetAttrValue('geogcs')
        shp_metadata_dict["origin_projection_name"] = prj_name

        shp_metadata_dict["origin_datum"] = spatialRef_from_layer.GetAttrValue(
            'datum')
        shp_metadata_dict["origin_unit"] = spatialRef_from_layer.GetAttrValue(
            'unit')
    else:
        shp_metadata_dict["origin_projection_string"] = UNKNOWN_STR
        shp_metadata_dict["origin_projection_name"] = UNKNOWN_STR
        shp_metadata_dict["origin_datum"] = UNKNOWN_STR
        shp_metadata_dict["origin_unit"] = UNKNOWN_STR

    field_list = []
    filed_attr_dic = {}
    field_meta_dict = {
        "field_list": field_list,
        "field_attr_dict": filed_attr_dic
    }
    shp_metadata_dict["field_meta_dict"] = field_meta_dict
    # get Attributes
    layerDefinition = layer.GetLayerDefn()
    for i in range(layerDefinition.GetFieldCount()):
        fieldName = layerDefinition.GetFieldDefn(i).GetName()
        field_list.append(fieldName)
        attr_dict = {}
        field_meta_dict["field_attr_dict"][fieldName] = attr_dict

        attr_dict["fieldName"] = fieldName
        fieldTypeCode = layerDefinition.GetFieldDefn(i).GetType()
        attr_dict["fieldTypeCode"] = fieldTypeCode
        fieldType = layerDefinition.GetFieldDefn(i).GetFieldTypeName(
            fieldTypeCode)
        attr_dict["fieldType"] = fieldType
        fieldWidth = layerDefinition.GetFieldDefn(i).GetWidth()
        attr_dict["fieldWidth"] = fieldWidth
        fieldPrecision = layerDefinition.GetFieldDefn(i).GetPrecision()
        attr_dict["fieldPrecision"] = fieldPrecision

    # get layer extent
    layer_extent = layer.GetExtent()

    # get feature count
    featureCount = layer.GetFeatureCount()
    shp_metadata_dict["feature_count"] = featureCount

    # get a feature from layer
    feature = layer.GetNextFeature()

    # get geometry from feature
    geom = feature.GetGeometryRef()

    # get geometry name
    shp_metadata_dict["geometry_type"] = geom.GetGeometryName()

    # reproject layer extent
    # source SpatialReference
    source = spatialRef_from_layer
    # target SpatialReference
    target = osr.SpatialReference()
    target.ImportFromEPSG(4326)

    # create two key points from layer extent
    left_upper_point = ogr.Geometry(ogr.wkbPoint)
    left_upper_point.AddPoint(layer_extent[0], layer_extent[3])  # left-upper
    right_lower_point = ogr.Geometry(ogr.wkbPoint)
    right_lower_point.AddPoint(layer_extent[1], layer_extent[2])  # right-lower

    # source map always has extent, even projection is unknown
    shp_metadata_dict["origin_extent_dict"] = {}
    shp_metadata_dict["origin_extent_dict"]["westlimit"] = layer_extent[0]
    shp_metadata_dict["origin_extent_dict"]["northlimit"] = layer_extent[3]
    shp_metadata_dict["origin_extent_dict"]["eastlimit"] = layer_extent[1]
    shp_metadata_dict["origin_extent_dict"]["southlimit"] = layer_extent[2]

    # reproject to WGS84
    shp_metadata_dict["wgs84_extent_dict"] = {}

    if source is not None:
        # define CoordinateTransformation obj
        transform = osr.CoordinateTransformation(source, target)
        # project two key points
        left_upper_point.Transform(transform)
        right_lower_point.Transform(transform)
        shp_metadata_dict["wgs84_extent_dict"][
            "westlimit"] = left_upper_point.GetX()
        shp_metadata_dict["wgs84_extent_dict"][
            "northlimit"] = left_upper_point.GetY()
        shp_metadata_dict["wgs84_extent_dict"][
            "eastlimit"] = right_lower_point.GetX()
        shp_metadata_dict["wgs84_extent_dict"][
            "southlimit"] = right_lower_point.GetY()
        shp_metadata_dict["wgs84_extent_dict"][
            "projection"] = "WGS 84 EPSG:4326"
        shp_metadata_dict["wgs84_extent_dict"]["units"] = "Decimal degrees"
    else:
        shp_metadata_dict["wgs84_extent_dict"]["westlimit"] = UNKNOWN_STR
        shp_metadata_dict["wgs84_extent_dict"]["northlimit"] = UNKNOWN_STR
        shp_metadata_dict["wgs84_extent_dict"]["eastlimit"] = UNKNOWN_STR
        shp_metadata_dict["wgs84_extent_dict"]["southlimit"] = UNKNOWN_STR
        shp_metadata_dict["wgs84_extent_dict"]["projection"] = UNKNOWN_STR
        shp_metadata_dict["wgs84_extent_dict"]["units"] = UNKNOWN_STR

    return shp_metadata_dict
            sys.exit(1)

    if radiusBand_num is not None:
        radiusBand = indataset.GetRasterBand(radiusBand_num)
        if radiusBand is None:
            print 'Could not get Radius band %d' % radiusBand_num
            sys.exit(1)

    geomatrix = indataset.GetGeoTransform()
    # Build Spatial Reference object based on coordinate system, fetched from the
    # opened dataset
    srs = osr.SpatialReference()
    srs.ImportFromWkt(indataset.GetProjection())
    #print srs
    srsLatLong = srs.CloneGeogCS()
    coordtransform = osr.CoordinateTransformation(srs, srsLatLong)

    # Collect information on all the source files.
    if srcwin is None:
        srcwin = (0, 0, indataset.RasterXSize, indataset.RasterYSize)

    # Open the output file.
    if dstfile is not None:
        dst_fh = open(dstfile, 'wt')
    else:
        dst_fh = sys.stdout

    if addheader:
        if printLatLon:
            dst_fh.write("Lon,Lat,Band\n")
        else:
예제 #27
0
    def compute_fields(self):
        """Other keyword args get passed in as a matter of course, like BBOX, time, and elevation, but this basic driver
        ignores them"""

        super(SpatialiteDriver, self).compute_fields()

        if not hasattr(self, "src_ext") and self.resource.resource_file:
            self.src_ext = self.resource.resource_file.split('.')[-1]

        # convert any other kind of file to spatialite.  this way the sqlite driver can be used with any OGR compatible
        # file
        if self.src_ext.endswith('zip'):
            archive = ZipFile(self.cached_basename + self.src_ext)
            projection_found = False
            for name in archive.namelist():
                xtn = name.split('.')[-1].lower()
                if xtn in {'shp', 'shx', 'dbf', 'prj'
                           } and "__MACOSX" not in name:
                    projection_found = projection_found or xtn == 'prj'
                    with open(self.cached_basename + '.' + xtn, 'wb') as fout:
                        with archive.open(name) as fin:
                            chunk = fin.read(65536)
                            while chunk:
                                fout.write(chunk)
                                chunk = fin.read(65536)

            if not projection_found:
                with open(self.cached_basename + '.prj', 'w') as f:
                    srs = osr.SpatialReference()
                    srs.ImportFromEPSG(4326)
                    f.write(srs.ExportToWkt())

            in_filename = self.get_filename('shp')
            out_filename = self.get_filename('sqlite')
            if os.path.exists(out_filename):
                os.unlink(out_filename)

            sh.ogr2ogr('-skipfailures', '-t_srs', 'epsg:3857', '-f', 'SQLite',
                       '-dsco', 'SPATIALITE=YES', out_filename, in_filename)
        elif self.src_ext.endswith('gz'):
            archive = TarFile(self.cached_basename + self.src_ext)
            projection_found = False
            for name in archive.getnames():
                xtn = name.split('.')[-1].lower()
                if xtn in {'shp', 'shx', 'dbf', 'prj'
                           } and "__MACOSX" not in name:
                    projection_found = projection_found or xtn == 'prj'
                    with open(self.cached_basename + '.' + xtn, 'wb') as fout:
                        with archive.open(name) as fin:
                            chunk = fin.read(65536)
                            while chunk:
                                fout.write(chunk)
                                chunk = fin.read(65536)

            if not projection_found:
                with open(self.cached_basename + '.prj', 'w') as f:
                    srs = osr.SpatialReference()
                    srs.ImportFromEPSG(4326)
                    f.write(srs.ExportToWkt())

            in_filename = self.get_filename('shp')
            out_filename = self.get_filename('sqlite')
            if os.path.exists(out_filename):
                os.unlink(out_filename)

            sh.ogr2ogr('-skipfailures', '-t_srs', 'epsg:3857', '-f', 'SQLite',
                       '-dsco', 'SPATIALITE=YES', out_filename, in_filename)
        elif not self.src_ext.endswith('sqlite'):
            in_filename = self.get_filename(self.src_ext)
            out_filename = self.get_filename('sqlite')

            if os.path.exists(out_filename):
                os.unlink(out_filename)

            sh.ogr2ogr('-skipfailures', '-t_srs', 'epsg:3857', '-f', 'SQLite',
                       '-dsco', 'SPATIALITE=YES', out_filename, in_filename)

        connection = self._connection()
        table, geometry_field, _, _, srid, _ = connection.execute(
            "select * from geometry_columns").fetchone(
            )  # grab the first layer with a geometry
        self._srid = srid if srid else 3857

        dataframe = self.get_filename('dfx')
        if os.path.exists(dataframe):
            os.unlink(dataframe)

        c = connection.cursor()
        c.execute(
            "select AsText(Extent(w.{geom_field})) from {table} as w".format(
                geom_field=geometry_field, table=table))

        try:
            xmin, ymin, xmax, ymax = GEOSGeometry(c.fetchone()[0]).extent
        except TypeError:
            xmin = ymin = xmax = ymax = 0.0

        crs = osr.SpatialReference()
        crs.ImportFromEPSG(srid)
        self.resource.native_srs = crs.ExportToProj4()

        e4326 = osr.SpatialReference()
        e4326.ImportFromEPSG(4326)
        crx = osr.CoordinateTransformation(crs, e4326)
        x04326, y04326, _ = crx.TransformPoint(xmin, ymin)
        x14326, y14326, _ = crx.TransformPoint(xmax, ymax)
        self.resource.bounding_box = Polygon.from_bbox(
            (x04326, y04326, x14326, y14326))
        self.resource.native_bounding_box = Polygon.from_bbox(
            (xmin, ymin, xmax, ymax))
        self.resource.three_d = False

        self.resource.save()
예제 #28
0
from osgeo import gdal
from osgeo import osr
from osgeo import ogr
import argparse
from subprocess import call

gdal.UseExceptions()

to_srs = 3857

source = osr.SpatialReference()
source.ImportFromEPSG(4326)
target = osr.SpatialReference()
target.ImportFromEPSG(3857)
transform = osr.CoordinateTransformation(source, target)


def parse_arguments():
    parser = argparse.ArgumentParser(
        prog="georeference_tif", description="This program geo references a TIFF image to make a GeoTIFF")
    parser.add_argument("src_file", nargs=1, help="Your input TIFF image")
    parser.add_argument("out_file", nargs=1, help="The output GeoTIFF image")
    parser.add_argument(
        "position", nargs=2, help="The upper left geographic position (Latitude Longitude)")
    parser.add_argument("pixelsize", nargs=2,
                        help="The pixel size in meters (Latitude Longitude)")
    return parser.parse_args()


def main():
예제 #29
0
# Read geotransform matrix and calculate ground coordinates
#geomatrix = indataset.GetGeoTransform()
#X = geomatrix[0] + geomatrix[1] * pixel + geomatrix[2] * line
#Y = geomatrix[3] + geomatrix[4] * pixel + geomatrix[5] * line

# Shift to the center of the pixel
#X += geomatrix[1] / 2.0
#Y += geomatrix[5] / 2.0

# Build Spatial Reference object based on coordinate system, fetched from the
# opened dataset
srs = osr.SpatialReference()
srs.ImportFromWkt(indataset.GetProjection())

srsLatLong = srs.CloneGeogCS()
ct = osr.CoordinateTransformation(srsLatLong, srs)
(minX, minY, height) = ct.TransformPoint(minlong, minlat)
(maxX, maxY, height) = ct.TransformPoint(maxlong, maxlat)

lines = abs(maxX - minX) / res
samples = abs(maxY - minY) / res

if bitType == 8:
    imageSizeMB = lines * samples * bands
elif bitType == 16:
    imageSizeMB = lines * samples * bands * 2
elif bitType == 32:
    imageSizeMB = lines * samples * bands * 4
else:
    print('bitType of %f not supported' % (bitType))
예제 #30
0
 def transform_shapes_ogr(self, infile,outfile,out_prj):
     (outfilepath, outfilename) = os.path.split(outfile)
     (outfileshortname, extension) = os.path.splitext(outfilename)
     driver = ogr.GetDriverByName('ESRI Shapefile')
     indataset = driver.Open(infile, 0)
     if indataset is None:
         print('Could not open file')
         sys.exit(1)
     inlayer = indataset.GetLayer()
     inSpatialRef = inlayer.GetSpatialRef()
     outSpatialRef = osr.SpatialReference()
     prj_file = open(out_prj, 'r')
     prj_txt = prj_file.read()
     outSpatialRef.ImportFromESRI([prj_txt]) # MODIS SINUSOIDAL GRID
     # create Coordinate Transformation
     coordTransform = osr.CoordinateTransformation(inSpatialRef, outSpatialRef)
     # Create the output shapefile but check first if file exists
     if os.path.exists(outfile):
         print(outfile, ' file already exists. Will try to delete')
         driver.DeleteDataSource(outfile)   #TODO:  This apparently does not work!
     outdataset = driver.CreateDataSource(outfile)
     if outdataset is None:
         print('Could not create file: ', outfile)
         sys.exit(1)
     outlayer = outdataset.CreateLayer(outfileshortname, geom_type=ogr.wkbPolygon)
     #iluk
     has_subbasin = False
     if has_field(inlayer, 'Subbasin'):
         feature = inlayer.GetFeature(0)
         fieldDefn1 = feature.GetFieldDefnRef('Subbasin')
         outlayer.CreateField(fieldDefn1)
         has_subbasin = True
     else:
         outlayer.CreateField(ogr.FieldDefn('Subbasin', ogr.OFTInteger))
     outlayer.CreateField(ogr.FieldDefn('surface', ogr.OFTReal))
     outlayer.CreateField(ogr.FieldDefn('rootzone', ogr.OFTReal))
     featureDefn = outlayer.GetLayerDefn()
     infeature = inlayer.GetNextFeature()
     index=1
     while infeature:
         #get the input geometry
         geometry = infeature.GetGeometryRef()
         #reproject the geometry, each one has to be projected seperately
         geometry.Transform(coordTransform)
         #create a new output feature
         outfeature = ogr.Feature(featureDefn)
         #set the geometry and attribute
         outfeature.SetGeometry(geometry)
         if has_subbasin:
             outfeature.SetField('Subbasin', infeature.GetField('Subbasin'))
         else:
             outfeature.SetField('Subbasin', index)
         #add the feature to the output shapefile
         outlayer.CreateFeature(outfeature)
         #destroy the features and get the next input features
         outfeature.Destroy
         infeature.Destroy
         infeature = inlayer.GetNextFeature()
         index += 1
     #close the shapefiles
     indataset.Destroy()
     outdataset.Destroy()
     #create the prj projection file
     outSpatialRef.MorphToESRI()
     file = open(outfilepath + '/'+ outfileshortname + '.prj', 'w')
     file.write(outSpatialRef.ExportToWkt())
     file.close()