def __call__(self, src_ds): dst_ds = create_mem(src_ds.RasterXSize, src_ds.RasterYSize, 1, gdal.GDT_Byte) if not self.palette_file: # create a color table as a median of the given dataset ct = gdal.ColorTable() gdal.ComputeMedianCutPCT(src_ds.GetRasterBand(1), src_ds.GetRasterBand(2), src_ds.GetRasterBand(3), 256, ct) else: # copy the color table from the given palette file pct_ds = gdal.Open(self.palette_file) pct_ct = pct_ds.GetRasterBand(1).GetRasterColorTable() if not pct_ct: raise ValueError("The palette file '%s' does not have a Color " "Table." % self.palette_file) ct = pct_ct.Clone() pct_ds = None dst_ds.GetRasterBand(1).SetRasterColorTable(ct) gdal.DitherRGB2PCT(src_ds.GetRasterBand(1), src_ds.GetRasterBand(2), src_ds.GetRasterBand(3), dst_ds.GetRasterBand(1), ct) copy_projection(src_ds, dst_ds) copy_metadata(src_ds, dst_ds) return dst_ds
def __call__(self, src_ds): # setup src_sr = osr.SpatialReference() src_sr.ImportFromWkt(src_ds.GetProjection()) dst_sr = osr.SpatialReference() dst_sr.ImportFromEPSG(self.srid) if src_sr.IsSame(dst_sr) and (src_ds.GetGeoTransform()[1] > 0) and (src_ds.GetGeoTransform()[5] < 0): logger.info( "Source and destination projection are equal and image " "is not flipped. Thus, no reprojection is required." ) return src_ds # create a temporary dataset to get information about the output size tmp_ds = gdal.AutoCreateWarpedVRT(src_ds, None, dst_sr.ExportToWkt(), gdal.GRA_Bilinear, 0.125) # create the output dataset dst_ds = create_mem( tmp_ds.RasterXSize, tmp_ds.RasterYSize, src_ds.RasterCount, src_ds.GetRasterBand(1).DataType ) # reproject the image dst_ds.SetProjection(dst_sr.ExportToWkt()) dst_ds.SetGeoTransform(tmp_ds.GetGeoTransform()) gdal.ReprojectImage(src_ds, dst_ds, src_sr.ExportToWkt(), dst_sr.ExportToWkt(), gdal.GRA_Bilinear) tmp_ds = None # copy the metadata copy_metadata(src_ds, dst_ds) return dst_ds
def __call__(self, src_ds): dst_ds = create_mem(src_ds.RasterXSize, src_ds.RasterYSize, len(self.bands), self.datatype) dst_range = get_limits(self.datatype) multiple = 0 for dst_index, (src_index, dmin, dmax) in enumerate(self.bands, 1): # check if next band is equal if dst_index < len(self.bands) and (src_index, dmin, dmax) == self.bands[dst_index]: multiple += 1 continue # check that src band is available if src_index > src_ds.RasterCount: continue # initialize with zeros if band is 0 if src_index == 0: src_band = src_ds.GetRasterBand(1) data = numpy.zeros((src_band.YSize, src_band.XSize), dtype=gdal_array.codes[self.datatype]) src_min, src_max = (0, 0) # use src_ds band otherwise else: src_band = src_ds.GetRasterBand(src_index) data = src_band.ReadAsArray() src_min, src_max = src_band.ComputeRasterMinMax() # get min/max values or calculate from band if dmin is None: dmin = get_limits(src_band.DataType)[0] elif dmin == "min": dmin = src_min if dmax is None: dmax = get_limits(src_band.DataType)[1] elif dmax == "max": dmax = src_max src_range = (float(dmin), float(dmax)) # perform clipping and scaling data = (dst_range[1] - dst_range[0]) * ( (numpy.clip(data, dmin, dmax) - src_range[0]) / (src_range[1] - src_range[0]) ) # set new datatype data = data.astype(gdal_array.codes[self.datatype]) # write result dst_band = dst_ds.GetRasterBand(dst_index) dst_band.WriteArray(data) # write equal bands at once if multiple > 0: for i in range(multiple): dst_band = dst_ds.GetRasterBand(dst_index - 1 - i) dst_band.WriteArray(data) multiple = 0 copy_projection(src_ds, dst_ds) copy_metadata(src_ds, dst_ds) return dst_ds
def _generate_footprint_wkt(self, ds): """ Generate a fooptrint from a raster, using black/no-data as exclusion """ # create an empty boolean array initialized as 'False' to store where # values exist as a mask array. nodata_map = numpy.zeros((ds.RasterYSize, ds.RasterXSize), dtype=numpy.bool) for idx in range(1, ds.RasterCount + 1): band = ds.GetRasterBand(idx) raster_data = band.ReadAsArray() nodata = band.GetNoDataValue() if nodata is None: nodata = 0 # apply the output to the map nodata_map |= (raster_data != nodata) # create a temporary in-memory dataset and write the nodata mask # into its single band tmp_ds = create_mem(ds.RasterXSize + 2, ds.RasterYSize + 2, 1, gdal.GDT_Byte) copy_projection(ds, tmp_ds) tmp_band = tmp_ds.GetRasterBand(1) tmp_band.WriteArray(nodata_map.astype(numpy.uint8)) # create an OGR in memory layer to hold the created polygon sr = osr.SpatialReference(); sr.ImportFromWkt(ds.GetProjectionRef()) ogr_ds = ogr.GetDriverByName('Memory').CreateDataSource('out') layer = ogr_ds.CreateLayer('poly', sr.sr, ogr.wkbPolygon) fd = ogr.FieldDefn('DN', ogr.OFTInteger) layer.CreateField(fd) # polygonize the mask band and store the result in the OGR layer gdal.Polygonize(tmp_band, tmp_band, layer, 0) if layer.GetFeatureCount() != 1: # if there is more than one polygon, compute the minimum bounding polygon geometry = ogr.Geometry(ogr.wkbPolygon) while True: feature = layer.GetNextFeature() if not feature: break geometry = geometry.Union(feature.GetGeometryRef()) # TODO: improve this for a better minimum bounding polygon geometry = geometry.ConvexHull() else: # obtain geometry from the first (and only) layer feature = layer.GetNextFeature() geometry = feature.GetGeometryRef() if geometry.GetGeometryType() != ogr.wkbPolygon: raise RuntimeError("Error during poligonization. Wrong geometry " "type.") # check if reprojection to latlon is necessary if not sr.IsGeographic(): dst_sr = osr.SpatialReference(); dst_sr.ImportFromEPSG(4326) try: geometry.TransformTo(dst_sr.sr) except RuntimeError: geometry.Transform(osr.CoordinateTransformation(sr.sr, dst_sr.sr)) gt = ds.GetGeoTransform() resolution = min(abs(gt[1]), abs(gt[5])) simplification_value = self.simplification_factor * resolution # simplify the polygon. the tolerance value is *really* vague try: # SimplifyPreserveTopology() available since OGR 1.9.0 geometry = geometry.SimplifyPreserveTopology(simplification_value) except AttributeError: # use GeoDjango bindings if OGR is too old geometry = ogr.CreateGeometryFromWkt(GEOSGeometry(geometry.ExportToWkt()).simplify(simplification_value, True).wkt) return geometry.ExportToWkt()
def apply(self, src_ds): # setup dst_sr = osr.SpatialReference() gcp_sr = osr.SpatialReference() dst_sr.ImportFromEPSG(self.srid if self.srid is not None else self.gcp_srid) gcp_sr.ImportFromEPSG(self.gcp_srid) logger.debug("Using GCP Projection '%s'" % gcp_sr.ExportToWkt()) logger.debug( "Applying GCPs: MULTIPOINT(%s) -> MULTIPOINT(%s)" % ( ", ".join([("(%f %f)") % (gcp.GCPX, gcp.GCPY) for gcp in self.gcps]), ", ".join([("(%f %f)") % (gcp.GCPPixel, gcp.GCPLine) for gcp in self.gcps]), ) ) # set the GCPs src_ds.SetGCPs(self.gcps, gcp_sr.ExportToWkt()) # Try to find and use the best transform method/order. # Orders are: -1 (TPS), 3, 2, and 1 (all GCP) # Loop over the min and max GCP number to order map. for min_gcpnum, max_gcpnum, order in [(3, None, -1), (10, None, 3), (6, None, 2), (3, None, 1)]: # if the number of GCP matches if len(self.gcps) >= min_gcpnum and (max_gcpnum is None or len(self.gcps) <= max_gcpnum): try: if order < 0: # let the reftools suggest the right interpolator rt_prm = rt.suggest_transformer(src_ds) else: # use the polynomial GCP interpolation as requested rt_prm = {"method": rt.METHOD_GCP, "order": order} logger.debug( "Trying order '%i' {method:%s,order:%s}" % (order, rt.METHOD2STR[rt_prm["method"]], rt_prm["order"]) ) # get the suggested pixel size/geotransform size_x, size_y, geotransform = rt.suggested_warp_output( src_ds, None, dst_sr.ExportToWkt(), **rt_prm ) if size_x > 100000 or size_y > 100000: raise RuntimeError("Calculated size exceeds limit.") logger.debug("New size is '%i x %i'" % (size_x, size_y)) # create the output dataset dst_ds = create_mem(size_x, size_y, src_ds.RasterCount, src_ds.GetRasterBand(1).DataType) # reproject the image dst_ds.SetProjection(dst_sr.ExportToWkt()) dst_ds.SetGeoTransform(geotransform) rt.reproject_image(src_ds, "", dst_ds, "", **rt_prm) copy_metadata(src_ds, dst_ds) # retrieve the footprint from the given GCPs footprint_wkt = rt.get_footprint_wkt(src_ds, **rt_prm) except RuntimeError, e: logger.debug("Failed using order '%i'. Error was '%s'." % (order, str(e))) # the given method was not applicable, use the next one continue else: logger.debug("Successfully used order '%i'" % order) # the transform method was successful, exit the loop break
def _generate_footprint_wkt(self, ds): """ Generate a footprint from a raster, using black/no-data as exclusion """ # create an empty boolean array initialized as 'False' to store where # values exist as a mask array. nodata_map = numpy.zeros((ds.RasterYSize, ds.RasterXSize), dtype=numpy.bool) for idx in range(1, ds.RasterCount + 1): band = ds.GetRasterBand(idx) raster_data = band.ReadAsArray() nodata = band.GetNoDataValue() if nodata is None: nodata = 0 # apply the output to the map nodata_map |= (raster_data != nodata) # create a temporary in-memory dataset and write the nodata mask # into its single band tmp_ds = create_mem(ds.RasterXSize + 2, ds.RasterYSize + 2, 1, gdal.GDT_Byte) copy_projection(ds, tmp_ds) tmp_band = tmp_ds.GetRasterBand(1) tmp_band.WriteArray(nodata_map.astype(numpy.uint8)) # create an OGR in memory layer to hold the created polygon sr = osr.SpatialReference() sr.ImportFromWkt(ds.GetProjectionRef()) ogr_ds = ogr.GetDriverByName('Memory').CreateDataSource('out') layer = ogr_ds.CreateLayer('poly', sr.sr, ogr.wkbPolygon) fd = ogr.FieldDefn('DN', ogr.OFTInteger) layer.CreateField(fd) # polygonize the mask band and store the result in the OGR layer gdal.Polygonize(tmp_band, tmp_band, layer, 0) if layer.GetFeatureCount() > 1: # if there is more than one polygon, compute the minimum # bounding polygon geometry = ogr.Geometry(ogr.wkbPolygon) while True: feature = layer.GetNextFeature() if not feature: break geometry = geometry.Union(feature.GetGeometryRef()) # TODO: improve this for a better minimum bounding polygon geometry = geometry.ConvexHull() elif layer.GetFeatureCount() < 1: # there was an error during polygonization raise RuntimeError("Error during polygonization. No feature " "obtained.") else: # obtain geometry from the first (and only) layer feature = layer.GetNextFeature() geometry = feature.GetGeometryRef() if geometry.GetGeometryType() != ogr.wkbPolygon: raise RuntimeError("Error during polygonization. Wrong geometry " "type: %s" % ogr.GeometryTypeToName( geometry.GetGeometryType())) # check if reprojection to latlon is necessary if not sr.IsGeographic(): dst_sr = osr.SpatialReference() dst_sr.ImportFromEPSG(4326) try: geometry.TransformTo(dst_sr.sr) except RuntimeError: geometry.Transform(osr.CoordinateTransformation(sr.sr, dst_sr.sr)) gt = ds.GetGeoTransform() resolution = min(abs(gt[1]), abs(gt[5])) simplification_value = self.simplification_factor * resolution # simplify the polygon. the tolerance value is *really* vague try: # SimplifyPreserveTopology() available since OGR 1.9.0 geometry = geometry.SimplifyPreserveTopology(simplification_value) except AttributeError: # use GeoDjango bindings if OGR is too old geometry = ogr.CreateGeometryFromWkt( GEOSGeometry(geometry.ExportToWkt()).simplify( simplification_value, True ).wkt ) return geometry.ExportToWkt()
def apply(self, src_ds): # setup dst_sr = osr.SpatialReference() gcp_sr = osr.SpatialReference() dst_sr.ImportFromEPSG(self.srid if self.srid is not None else self.gcp_srid) gcp_sr.ImportFromEPSG(self.gcp_srid) logger.debug("Using GCP Projection '%s'" % gcp_sr.ExportToWkt()) logger.debug("Applying GCPs: MULTIPOINT(%s) -> MULTIPOINT(%s)" % (", ".join([("(%f %f)") % (gcp.GCPX, gcp.GCPY) for gcp in self.gcps]) , ", ".join([("(%f %f)") % (gcp.GCPPixel, gcp.GCPLine) for gcp in self.gcps]))) # set the GCPs src_ds.SetGCPs(self.gcps, gcp_sr.ExportToWkt()) # Try to find and use the best transform method/order. # Orders are: -1 (TPS), 3, 2, and 1 (all GCP) # Loop over the min and max GCP number to order map. for min_gcpnum, max_gcpnum, order in [(3, None, -1), (10, None, 3), (6, None, 2), (3, None, 1)]: # if the number of GCP matches if len(self.gcps) >= min_gcpnum and (max_gcpnum is None or len(self.gcps) <= max_gcpnum): try: if ( order < 0 ) : # let the reftools suggest the right interpolator rt_prm = rt.suggest_transformer( src_ds ) else: # use the polynomial GCP interpolation as requested rt_prm = { "method":rt.METHOD_GCP, "order":order } logger.debug("Trying order '%i' {method:%s,order:%s}" % \ (order, rt.METHOD2STR[rt_prm["method"]] , rt_prm["order"] ) ) # get the suggested pixel size/geotransform size_x, size_y, geotransform = rt.suggested_warp_output( src_ds, None, dst_sr.ExportToWkt(), **rt_prm ) if size_x > 100000 or size_y > 100000: raise RuntimeError("Calculated size exceeds limit.") logger.debug("New size is '%i x %i'" % (size_x, size_y)) # create the output dataset dst_ds = create_mem(size_x, size_y, src_ds.RasterCount, src_ds.GetRasterBand(1).DataType) # reproject the image dst_ds.SetProjection(dst_sr.ExportToWkt()) dst_ds.SetGeoTransform(geotransform) rt.reproject_image(src_ds, "", dst_ds, "", **rt_prm ) copy_metadata(src_ds, dst_ds) # retrieve the footprint from the given GCPs footprint_wkt = rt.get_footprint_wkt(src_ds, **rt_prm ) except RuntimeError as e: logger.debug("Failed using order '%i'. Error was '%s'." % (order, str(e))) # the given method was not applicable, use the next one continue else: logger.debug("Successfully used order '%i'" % order) # the transform method was successful, exit the loop break else: # no method worked, so raise an error raise GCPTransformException("Could not find a valid transform method.") # reproject the footprint to a lon/lat projection if necessary if not gcp_sr.IsGeographic(): out_sr = osr.SpatialReference() out_sr.ImportFromEPSG(4326) geom = ogr.CreateGeometryFromWkt(footprint_wkt, gcp_sr) geom.TransformTo(out_sr) footprint_wkt = geom.ExportToWkt() logger.debug("Calculated footprint: '%s'." % footprint_wkt) return dst_ds, footprint_wkt
def apply(self, src_ds): # setup dst_sr = osr.SpatialReference() dst_sr.ImportFromEPSG(self.srid) logger.debug("Using internal GCP Projection.") num_gcps = src_ds.GetGCPCount() # Try to find and use the best transform method/order. # Orders are: -1 (TPS), 3, 2, and 1 (all GCP) # Loop over the min and max GCP number to order map. for min_gcpnum, max_gcpnum, order in [(3, None, -1), (10, None, 3), (6, None, 2), (3, None, 1)]: # if the number of GCP matches if num_gcps >= min_gcpnum and (max_gcpnum is None or num_gcps <= max_gcpnum): try: if (order < 0): # let the reftools suggest the right interpolator rt_prm = reftools.suggest_transformer(src_ds) else: # use the polynomial GCP interpolation as requested rt_prm = { "method": reftools.METHOD_GCP, "order": order } logger.debug("Trying order '%i' {method:%s,order:%s}" % (order, reftools.METHOD2STR[rt_prm["method"]], rt_prm["order"])) # get the suggested pixel size/geotransform size_x, size_y, gt = reftools.suggested_warp_output( src_ds, None, dst_sr.ExportToWkt(), **rt_prm) if size_x > 100000 or size_y > 100000: raise RuntimeError("Calculated size exceeds limit.") logger.debug("New size is '%i x %i'" % (size_x, size_y)) # create the output dataset dst_ds = create_mem(size_x, size_y, src_ds.RasterCount, src_ds.GetRasterBand(1).DataType) # reproject the image dst_ds.SetProjection(dst_sr.ExportToWkt()) dst_ds.SetGeoTransform(gt) reftools.reproject_image(src_ds, "", dst_ds, "", **rt_prm) copy_metadata(src_ds, dst_ds) # retrieve the footprint from the given GCPs footprint_wkt = reftools.get_footprint_wkt( src_ds, **rt_prm) except RuntimeError, e: logger.debug("Failed using order '%i'. Error was '%s'." % (order, str(e))) # the given method was not applicable, use the next one continue else: logger.debug("Successfully used order '%i'" % order) # the transform method was successful, exit the loop break