def main(shapefile_path, raster_path): # Load the source data as a gdalnumeric array srcArray = gdalnumeric.LoadFile(raster_path) # Also load as a gdal image to get geotransform # (world file) info pdb.set_trace() srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() # Create an OGR layer from a boundary shapefile shapef = ogr.Open(shapefile_path) lyr = shapef.GetLayer( os.path.split(os.path.splitext(shapefile_path)[0])[1]) poly = lyr.GetNextFeature() # Convert the layer extent to image pixel coordinates minX, maxX, minY, maxY = lyr.GetExtent() ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) # Calculate the pixel size of the new image pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[:, ulY:ulY + 1000, ulX:ulX + 1000] # Save as an 8-bit jpeg for an easy, quick preview clip = clip.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip, "beijing3.jpg", format="JPEG")
def merge_floods(dirPaese): os.chdir(dirPaese) iso_paese = dirPaese.split("\\")[-1] print iso_paese stringa_ricerca = "*.tif" lista_floods_rcl = glob.glob(stringa_ricerca) print lista_floods_rcl for floodo in lista_floods_rcl: rp = floodo.split("_")[1].split(".")[0] if rp == '25': im_rp_25 = floodo elif rp == '50': im_rp_50 = floodo elif rp == '100': im_rp_100 = floodo elif rp == '200': im_rp_200 = floodo elif rp == '500': im_rp_500 = floodo elif rp == '1000': im_rp_1000 = floodo ar25 = gdalnumeric.LoadFile(im_rp_25).astype(np.int16) ar50 = gdalnumeric.LoadFile(im_rp_50).astype(np.int16) ar100 = gdalnumeric.LoadFile(im_rp_100).astype(np.int16) ar200 = gdalnumeric.LoadFile(im_rp_200).astype(np.int16) ar500 = gdalnumeric.LoadFile(im_rp_500).astype(np.int16) ar1000 = gdalnumeric.LoadFile(im_rp_1000).astype(np.int16) somma = ar25 + ar50 + ar100 + ar200 + ar500 + ar1000 gdalnumeric.SaveArray(somma, dirPaese + "\\" + iso_paese + "_all_rp.tif", format="GTiff", prototype=im_rp_1000)
def main(shapefile_path, raster_path, fileName): # 读取栅格影像路径 srcArray = gdalnumeric.LoadFile(raster_path) # 读取栅格据 srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() # 读取矢量图形数据路径 shapef = ogr.Open(shapefile_path) lyr = shapef.GetLayer( os.path.split(os.path.splitext(shapefile_path)[0])[1]) poly = lyr.GetNextFeature() # 矢量图形坐标换算 minX, maxX, minY, maxY = lyr.GetExtent() ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) # 计算新生成图像大小 pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[:, ulY:lrY, ulX:lrX] xoffset = ulX yoffset = ulY print("Xoffset, Yoffset = ( %f, %f )" % (xoffset, yoffset)) # 创建geomatrix geoTrans = list(geoTrans) geoTrans[0] = minX geoTrans[3] = maxY # 创建一张黑白遮罩图像,将矢量点集映射到像素上 points = [] pixels = [] geom = poly.GetGeometryRef() pts = geom.GetGeometryRef(0) for p in range(pts.GetPointCount()): points.append((pts.GetX(p), pts.GetY(p))) for p in points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) # 裁剪遮罩 clip = gdalnumeric.choose(mask, (clip, 0)).astype(gdalnumeric.int16) clip = clip.astype(gdalnumeric.int16) #加载GTiff驱动,存储结果为tiff图像 gtiffDriver = gdal.GetDriverByName('GTiff') if gtiffDriver is None: raise ValueError("Can't load GeoTiff Driver") print(type(clip)) gdalnumeric.SaveArray(clip, fileName, format="GTiff") print("裁剪完毕") gdal.ErrorReset()
def merge_floods(paese): os.chdir("C:/data/tools/sparc/input_data/flood/masks/") stringa_ricerca = "%s*.tif" % paese lista_floods_rcl = glob.glob(stringa_ricerca) print lista_floods_rcl im_rp_25 = lista_floods_rcl[3] im_rp_50 = lista_floods_rcl[5] im_rp_100 = lista_floods_rcl[1] im_rp_200 = lista_floods_rcl[2] im_rp_500 = lista_floods_rcl[4] im_rp_1000 = lista_floods_rcl[0] ar25 = gdalnumeric.LoadFile(im_rp_25).astype(np.int16) ar50 = gdalnumeric.LoadFile(im_rp_50).astype(np.int16) ar100 = gdalnumeric.LoadFile(im_rp_100).astype(np.int16) ar200 = gdalnumeric.LoadFile(im_rp_200).astype(np.int16) ar500 = gdalnumeric.LoadFile(im_rp_500).astype(np.int16) ar1000 = gdalnumeric.LoadFile(im_rp_1000).astype(np.int16) somma = ar25 + ar50 + ar100 + ar200 + ar500 + ar1000 gdalnumeric.SaveArray(somma, "C:/data/tools/sparc/input_data/flood/merged/" + paese + "_all_rp.tif", format="GTiff", prototype=im_rp_1000)
def main(): RasterFilePath = sys.argv[1] #Raster input as MSI MSIImage = gdal.Open(RasterFilePath) infotext = os.system('gdalinfo' + ' ' + RasterFilePath) print infotext XSize = MSIImage.RasterXSize YSize = MSIImage.RasterYSize MSIGeoTrans = MSIImage.GetGeoTransform() print MSIGeoTrans pixelSizeX = MSIGeoTrans[1] pixelSizeY = MSIGeoTrans[5] RasterBand_Count = MSIImage.RasterCount print XSize, YSize, RasterBand_Count, pixelSizeX, pixelSizeY for i in range(RasterBand_Count): bandarray = np.array(MSIImage.GetRasterBand(i + 1).ReadAsArray()) print bandarray.shape #print bandarray #Shapefile for landusage ShapeFilePath = sys.argv[2] SHPFILE_LandUsage = ogr.Open(ShapeFilePath) layer = SHPFILE_LandUsage.GetLayer(0) minX, maxX, minY, maxY = layer.GetExtent() raster_minX = -81.690277778 #Hardcoded with following 3 lines raster_minY = 30.298888889 raster_maxX = -81.456388889 raster_maxY = 30.400555556 if (minX < raster_minX): X_translate = abs(minX - raster_minX) if (minY < raster_minY): Y_translate = abs(minY - raster_minY) xDist = 0.000025379 #geoMatrix[1] #Hardcoded 2 lines yDist = 0.000014183 #geoMatrix[5] X_translate_pixels = int(X_translate / xDist) Y_translate_pixels = int(Y_translate / yDist) print minX, raster_minX, minY, raster_minY, maxX, raster_maxX, maxY, raster_maxY ulX, ulY = world2pixelraster(MSIGeoTrans, raster_minX, raster_maxY) lrX, lrY = world2pixelraster(MSIGeoTrans, raster_maxX, raster_minY) s_ulX, s_ulY = world2pixelraster(MSIGeoTrans, minX, maxY) s_lrX, s_lrY = world2pixelraster(MSIGeoTrans, maxX, minY) #ulX=ulX+X_translate_pixels #ulY=ulY+Y_translate_pixels #lrX=lrX+X_translate_pixels #lrY=lrY+Y_translate_pixels print('Pixel Extent', ulX, lrX, ulY, lrY) pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) srcArray = np.zeros((8, YSize, XSize), dtype=float) #srcArray=gdalnumeric.LoadFile('/projects/bialvm/Jhimli/MSI_JacksonVille_WV2/05SEP16WV021200016SEP05162552-M1BS-500881026010_01_P006_________GA_E0AAAAAAIAAG0.NTF')#(np.zeros((8,YSize,XSize),dtype=float) for i in range(RasterBand_Count): bandarray = np.array( MSIImage.GetRasterBand(i + 1).ReadAsArray().astype(np.float32)) srcArray[i, :, :] = bandarray cliparray = srcArray[:, ulY:lrY, ulX:lrX] newclip = np.zeros((pxHeight, pxWidth, 8), dtype=float) for i in range(0, 8): newclip[:, :, i] = cliparray[i, :, :] OutputFolderPath = sys.argv[3] cv2.imwrite(os.path.join(OutputFolderPath + 'clipraster.png'), newclip[:, :, 1]) #pdb.set_trace() xoffset = s_ulX yoffset = s_ulY print(lrY, s_lrY) scale_Y = float(lrY) / float(s_lrY) scale_X = float(ulX) / float(s_ulX) print('YScale:', scale_Y) print('XScale:', scale_X) print('Xoffset', xoffset, 'Yoffset', yoffset) geoTrans = list(MSIGeoTrans) geoTrans[0] = minX geoTrans[3] = maxY print geoTrans[0], geoTrans[3] #ds=gdal.GetDriverByName('gtiff').Create('/projects/bialvm/Jhimli/wood_raster.tif',XSize,YSize,1) #ds.SetGeoTransform([ulx,1,0,uly,0,-1]) #print layer.GetSpatialRef().ExportToWkt() #ds.SetProjection(layer.GetSpatialRef().ExportToWkt()) #Extracting geometry by material type from shape file landuasages multipolygon = ogr.Geometry(ogr.wkbMultiPolygon) layer.SetAttributeFilter("type='stadium'") #print layer #new_band=ds.GetRasterBand(1) #new_band.SetNoDataValue(0) #gdal.RasterizeLayer(ds,[1],layer,None, None, [1], ['ALL_TOUCHED=TRUE']) allpoly = [] for feature in layer: type_name = feature.GetField("type") geometry = feature.GetGeometryRef() rcnt = 0 for ring in geometry: rcnt += 1 points = ring.GetPointCount() pcnt = 0 poly_coords = [] poly_pixels = [] for p in xrange(points): pcnt += 1 lon, lat, z = ring.GetPoint(p) #print lon,lat,z poly_coords.append([lon, lat]) for p in poly_coords: px_X, px_Y = world2pixelshape(geoTrans, p[0], p[1]) poly_pixels.append((px_X - xoffset, int(px_Y * scale_Y))) allpoly.append(poly_pixels) print allpoly rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) for i in range(len(allpoly)): print allpoly[i] rasterize.polygon(allpoly[i], 0) print(pxWidth, pxHeight) mask = imageToArray(rasterPoly) mask = mask.astype(gdalnumeric.uint8) maskFileName = os.path.join(OutputFolderPath + 'mask.jpg') gdalnumeric.SaveArray(mask * 255, maskFileName, format="JPEG") for i in range(8): cliparray[i, :, :] = cliparray[i, :, :] # Save as an 8-bit jpeg for an easy, quick preview clipImage = np.zeros((pxHeight, pxWidth, 3), dtype=np.uint8) for kk in range(0, 3): clipImage[:, :, kk] = cliparray[kk, :, :].astype(gdalnumeric.uint8) #mask=mask.astype(gdalnumeric.uint8) new_mask = np.zeros((mask.shape[0], mask.shape[1], 3), dtype=np.uint8) new_mask[:, :, 0] = 255 * mask new_mask[:, :, 1] = mask new_mask[:, :, 2] = mask #pdb.set_trace() result_img = cv2.addWeighted(new_mask, 0.5, clipImage, 0.5, 0) ShapeMaskOnRasterFile = os.path.join(OutputFolderPath + 'OUTPUT.png') cv2.imwrite(ShapeMaskOnRasterFile, result_img) #gdalnumeric.SaveArray(clipImage, "/projects/bialvm/Jhimli/OUTPUT.jpg", format="JPEG") '''
# Numpy/gdalnumeric - Read an image, extract a band, save a new image # https://github.com/GeospatialPython/Learning/raw/master/SatImage.zip from osgeo import gdalnumeric srcArray = gdalnumeric.LoadFile("SatImage.tif") band1 = srcArray[0] gdalnumeric.SaveArray(band1, "band1.jpg", format="JPEG")
def clip(tiff_gt, tiff_arr, geom, no_data=-10000, clip_save_name='', is_clip_saved_in_png=True): ''' Clip GeoTiff from `tiff_path` with ShapeFile from `shape_path`. Parameters ---------- tiff : osgeo.gdal.Dataset path to `.tif` file shape_path : osgeo.ogr.DataSource path to `.shp` file :param clip_save_name: the name of saving clip. Empty string '' to not save. i.e. 'clipped-img' :param is_clip_saved_in_png: True to save in PNG (8-bit), and False to save in GeoTiff format (Float32) ''' gdal.UseExceptions() # tiff_arr_shape = tiff_arr.shape # tiff_pxl_ext = eu.tup_to_dic(( # 0, tiff_arr_shape[0], # 0, tiff_arr_shape[1], # )) geom_pts = get_pts_in_geom(geom) # Get the geo-extent of the geo polygon geom_ext = make_geom_ext(geom_pts) # Get the geo extent in pixel coordinates geom_pxl_ext = { k: int(v) for k, v in eu.apply_gt(gdal.InvGeoTransform(tiff_gt), geom_ext).items() } geom_gt = make_geom_gt(tiff_gt, geom_ext) geom_inv_gt = gdal.InvGeoTransform(geom_gt) tiff_shape = tiff_arr.shape if geom_pxl_ext['min_y'] < 0: geom_pxl_ext['min_y'] = 0 if geom_pxl_ext['min_x'] < 0: geom_pxl_ext['min_x'] = 0 if geom_pxl_ext['max_y'] < 0: geom_pxl_ext['max_y'] = 0 if geom_pxl_ext['max_x'] < 0: geom_pxl_ext['max_x'] = 0 # Extract data from dsm (tiff_arr) to the extent (clipped_arr) if len(tiff_shape) == 3: bound_tiff_y = tiff_shape[1] - 1 bound_tiff_x = tiff_shape[2] - 1 if geom_pxl_ext['max_y'] > bound_tiff_y: geom_pxl_ext['max_y'] = bound_tiff_y if geom_pxl_ext['max_x'] > bound_tiff_x: geom_pxl_ext['max_x'] = bound_tiff_x clipped_arr = tiff_arr[:, geom_pxl_ext['min_y']:geom_pxl_ext['max_y'] + 1, geom_pxl_ext['min_x']:geom_pxl_ext['max_x'] + 1, ] else: bound_tiff_y = tiff_shape[0] - 1 bound_tiff_x = tiff_shape[1] - 1 if geom_pxl_ext['max_y'] > bound_tiff_y: geom_pxl_ext['max_y'] = bound_tiff_y if geom_pxl_ext['max_x'] > bound_tiff_x: geom_pxl_ext['max_x'] = bound_tiff_x clipped_arr = tiff_arr[np.newaxis, geom_pxl_ext['min_y']:geom_pxl_ext['max_y'] + 1, geom_pxl_ext['min_x']:geom_pxl_ext['max_x'] + 1, ] # Convert the geo-polygon-points from geo-referenced to coordinates in Pixel (based on the extent) pxls = [ tuple(map(int, gdal.ApplyGeoTransform(geom_inv_gt, x, y))) for (x, y) in geom_pts ] # FIXME: # This code make incorrect volume. # For example, when you have a triangle with # one point going outside to the map, # the point will be filtered and result volume will be 0. ext_bound_x = geom_pxl_ext['max_x'] - geom_pxl_ext['min_x'] ext_bound_y = geom_pxl_ext['max_y'] - geom_pxl_ext['min_y'] clipped_pxls = [(x, y) for (x, y) in pxls if 0 <= x <= ext_bound_x and 0 <= y <= ext_bound_y] if len(clipped_pxls) < 2: return np.array([]), [] raster_size = (ext_bound_x + 1, ext_bound_y + 1) raster_poly = Image.new('L', raster_size, color=0x000001) ImageDraw.Draw(raster_poly).polygon(clipped_pxls, fill=0x000000) # TODO: Add error handlings for ValueError mask = np.fromstring(raster_poly.tobytes(), dtype=np.int8) \ .reshape(raster_poly.im.size[1], raster_poly.im.size[0]) clipped_arr = np.choose(mask, (clipped_arr, no_data)) boundary_pts = [clipped_arr[0, y, x] for (x, y) in clipped_pxls] ######### TESTING BEGIN # Save the clipped image to a PNG file if len(clip_save_name) > 0: if is_clip_saved_in_png: clippedData = clipped_arr.astype(np.int8) gdalnumeric.SaveArray(clippedData, clip_save_name + '.png', format="PNG") else: clippedData = clipped_arr.astype(np.float32) gdalnumeric.SaveArray(clippedData, clip_save_name + '.tif', format="GTiff") ######### TESTING END return clipped_arr, boundary_pts
''' from osgeo import gdal, gdalnumeric import numpy as np im1 = './data/remote_sensing/before.tif' im2 = './data/remote_sensing/after.tif' ar1 = gdalnumeric.LoadFile(im1).astype(np.int8) ar2 = gdalnumeric.LoadFile(im2)[1].astype(np.int8) diff = ar2 - ar1 classes = np.histogram(diff, bins=5)[1] lut = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 255, 0], [255, 0, 0]] start = 1 rgb = np.zeros(( 3, diff.shape[0], diff.shape[1], ), np.int8) for i in range(len(classes)): mask = np.logical_and(start <= diff, diff <= classes[i]) for j in range(len(lut[i])): rgb[j] = np.choose(mask, (rgb[j], lut[i][j])) start = classes[i] + 1 gdalnumeric.SaveArray(rgb, './data/remote_sensing/change.tif', format='GTiff', prototype=im2)
def gdalNum(): srcArray = gdalnumeric.LoadFile("SatImage.tif") band1 = srcArray[0] gdalnumeric.SaveArray(band1, "band1.jpg", format="JPEG")
# 地图上的点到用在空白的8位黑白掩模图像上绘制边界的像素 points = [] pixels = [] geom = poly.GetGeometryRef() pts = geom.GetGeometryRef(0) for p in range(pts.GetPointCount()): points.append((pts.GetX(p), pts.GetY(p))) for p in points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) # 用掩模裁剪图像 clip = gdalnumeric.choose(mask, (clip, 0)).astype(gdalnumeric.uint8) # 这个图像有3个波段,因此我们得拉伸每一个波段使得他们有更好的可视化效果 for i in range(3): clip[i, :, :] = stretch(clip[i, :, :]) # 将ndvi另存为tiff gdalnumeric.SaveArray(clip, "%s.tiff" % output, format="GTiff", prototype=raster) # 将ndvi保存为8位的jpeg,以便于快速预览 clip = clip.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip, "%s.jpg" % output, format="JPEG")
def clip_raster1(shapefile_path, raster_path): ''' This function will convert the rasterized clipper shapefile to a mask for use within GDAL. This comes (with slight modification) from: https://pcjericks.github.io/py-gdalogr-cookbook/raster_layers.html#clip-a-geotiff-with-shapefile which is an updated version of: http://geospatialpython.com/2011/02/clip-raster-using-shapefile.html ''' def imageToArray(i): """ Converts a Python Imaging Library array to a gdalnumeric image. """ a = gdalnumeric.fromstring(i.tostring(), 'b') a.shape = i.im.size[1], i.im.size[0] return a def arrayToImage(a): """ Converts a gdalnumeric array to a Python Imaging Library Image. """ i = Image.fromstring('L', (a.shape[1], a.shape[0]), (a.astype('b')).tostring()) return i def world2Pixel(geoMatrix, x, y): """ Uses a gdal geomatrix (gdal.GetGeoTransform()) to calculate the pixel location of a geospatial coordinate """ ulX = geoMatrix[0] ulY = geoMatrix[3] xDist = geoMatrix[1] yDist = geoMatrix[5] rtnX = geoMatrix[2] rtnY = geoMatrix[4] pixel = int((x - ulX) / xDist) line = int((ulY - y) / xDist) return (pixel, line) # EDIT: this is basically an overloaded # version of the gdal_array.OpenArray passing in xoff, yoff explicitly # so we can pass these params off to CopyDatasetInfo # def OpenArray(array, prototype_ds=None, xoff=0, yoff=0): ds = gdal.Open(gdalnumeric.GetArrayFilename(array)) if ds is not None and prototype_ds is not None: if type(prototype_ds).__name__ == 'str': prototype_ds = gdal.Open(prototype_ds) if prototype_ds is not None: gdalnumeric.CopyDatasetInfo(prototype_ds, ds, xoff=xoff, yoff=yoff) return ds def histogram(a, bins=range(0, 256)): """ Histogram function for multi-dimensional array. a = array bins = range of numbers to match """ fa = a.flat n = gdalnumeric.searchsorted(gdalnumeric.sort(fa), bins) n = gdalnumeric.concatenate([n, [len(fa)]]) hist = n[1:] - n[:-1] return hist def stretch(a): """ Performs a histogram stretch on a gdalnumeric array image. """ hist = histogram(a) im = arrayToImage(a) lut = [] for b in range(0, len(hist), 256): # step size step = reduce(operator.add, hist[b:b + 256]) / 255 # create equalization lookup table n = 0 for i in range(256): lut.append(n / step) n = n + hist[i + b] im = im.point(lut) return imageToArray(im) # Load the source data as a gdalnumeric array srcArray = gdalnumeric.LoadFile(raster_path) # Also load as a gdal image to get geotransform # (world file) info srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() # Create an OGR layer from a boundary shapefile shapef = ogr.Open(shapefile_path) lyr = shapef.GetLayer( os.path.split(os.path.splitext(shapefile_path)[0])[1]) poly = lyr.GetNextFeature() # Convert the layer extent to image pixel coordinates minX, maxX, minY, maxY = lyr.GetExtent() ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) # Calculate the pixel size of the new image pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[:, ulY:lrY, ulX:lrX] # # EDIT: create pixel offset to pass to new image Projection info # xoffset = ulX yoffset = ulY print("Xoffset, Yoffset = ( %f, %f )" % (xoffset, yoffset)) # Create a new geomatrix for the image geoTrans = list(geoTrans) geoTrans[0] = minX geoTrans[3] = maxY # Map points to pixels for drawing the # boundary on a blank 8-bit, # black and white, mask image. points = [] pixels = [] geom = poly.GetGeometryRef() pts = geom.GetGeometryRef(0) for p in range(pts.GetPointCount()): points.append((pts.GetX(p), pts.GetY(p))) for p in points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) # Clip the image using the mask clip = gdalnumeric.choose(mask, \ (clip, 0)).astype(gdalnumeric.uint8) # This image has 3 bands so we stretch each one to make them # visually brighter for i in range(3): clip[i, :, :] = stretch(clip[i, :, :]) # Save new tiff # # EDIT: instead of SaveArray, let's break all the # SaveArray steps out more explicity so # we can overwrite the offset of the destination # raster # ### the old way using SaveArray # # gdalnumeric.SaveArray(clip, "OUTPUT.tif", format="GTiff", # prototype=raster_path) # ### # gtiffDriver = gdal.GetDriverByName('GTiff') if gtiffDriver is None: raise ValueError("Can't find GeoTiff Driver") gtiffDriver.CreateCopy( "OUTPUT.tif", OpenArray(clip, prototype_ds=raster_path, xoff=xoffset, yoff=yoffset)) # Save as an 8-bit jpeg for an easy, quick preview clip = clip.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip, "OUTPUT.jpg", format="JPEG") gdal.ErrorReset() return (clip, ulX, ulY, geoTrans)
def downloadImage(request, result_id, band): if request.method == 'GET': resultImg = models.QueryResult.objects.filter(pk=result_id).first() if resultImg == None: raise Http404 tiles = list(resultImg.tileMatrix) src_srs = osr.SpatialReference() src_srs.ImportFromWkt(tiles[0].image.wkt) tgt_srs = osr.SpatialReference() tgt_srs.ImportFromEPSG(4326) tgt_srs = src_srs.CloneGeogCS() preClipDS, preClipSize, preClipGeoTransform = GetPreClipImage( tiles, band, resultImg.imageName, src_srs, tgt_srs) # print preClipGeoTransform # Raster of input polygons rasterPoly = Image.new("L", (preClipSize[0], preClipSize[1]), 1) rasterize = ImageDraw.Draw(rasterPoly) inputPolygons = resultImg.inputPolygons.polygons mostULx = mostLRx = mostULy = mostLRy = None for polygon in inputPolygons: pixels = [] inputPolygonReprojected = ReprojectCoords( polygon['coordinates'][0], tgt_srs, src_srs) for p in inputPolygonReprojected: pixels.append(world2Pixel(preClipGeoTransform, p[0], p[1])) pixels = intersectPolygonToBorder(pixels, preClipSize[0], preClipSize[1]) if pixels is None: continue print pixels if mostULx == None or \ mostLRx == None or \ mostULy == None or \ mostLRy == None: mostULx = mostLRx = pixels[0][0] mostULy = mostLRy = pixels[0][1] for x, y in pixels: if x > mostLRx: mostLRx = x if x < mostULx: mostULx = x if y < mostULy: mostULy = y if y > mostLRy: mostLRy = y # mostULx, mostULy = world2Pixel(preClipGeoTransform, mostULx, mostULy) # mostLRx, mostLRy = world2Pixel(preClipGeoTransform, mostLRx, mostLRy) mostULx = 0 if mostULx < 0 else mostULx mostLRx = 0 if mostLRx < 0 else mostLRx mostULy = 0 if mostULy < 0 else mostULy mostLRy = 0 if mostLRy < 0 else mostLRy rasterize.polygon(pixels, 0) print '%i %i %i %i' % (mostULx, mostULy, mostLRx, mostLRy) # clipped the output dataset by minimum rect clip = preClipDS.GetRasterBand(1).ReadAsArray( 0, 0, preClipSize[0], preClipSize[1])[mostULy:mostLRy, mostULx:mostLRx] # create mask to clip image by polygon mask = imageToArray(rasterPoly)[mostULy:mostLRy, mostULx:mostLRx] # Clip the image using the mask clip = gdalnumeric.choose(mask, (clip, 0)).astype(gdalnumeric.uint16) finalFile = NamedTemporaryFile(suffix='.tif', prefix=resultImg.imageName + '-' + str(band)) gdalnumeric.SaveArray(clip, str(finalFile.name), format="GTiff") clippedGeoTransform = [ preClipGeoTransform[0] + mostULx * preClipGeoTransform[1], preClipGeoTransform[1], preClipGeoTransform[2], preClipGeoTransform[3] + mostULy * preClipGeoTransform[5], preClipGeoTransform[4], preClipGeoTransform[5] ] ds = gdal.Open(str(finalFile.name), gdal.GA_Update) ds.SetGeoTransform(clippedGeoTransform) ds.SetProjection(src_srs.ExportToWkt()) # Return HttpResponse Image wrapper = FileWrapper(finalFile) content_type = mimetypes.guess_type(finalFile.name)[0] response = StreamingHttpResponse(wrapper, content_type='content_type') response[ 'Content-Disposition'] = "attachment; filename=%s" % finalFile.name return response # return HttpResponse(json.dumps(dict(out=output_geo_transform, # ext=ext, # finalXSize=finalXSize, # finalYSize=finalYSize))) raise Http404
''' Created on Aug 19, 2015 @author: trucvietle ''' from osgeo import gdalnumeric src = './data/remote_sensing/FalseColor.tif' arr = gdalnumeric.LoadFile(src) gdalnumeric.SaveArray(arr[[1, 0, 2], :], './data/remote_sensing/swap.tif', format='GTiff', prototype=src)
__author__ = 'Fabio' from osgeo import gdal raster = gdal.Open("../dati/SatImage/SatImage.tif") print("Bande :" + str(raster.RasterCount)) print("Pixel in X :" + str(raster.RasterXSize)) print("Pixel in Y :" + str(raster.RasterYSize)) from osgeo import gdalnumeric srcArray = gdalnumeric.LoadFile("../dati/SatImage/SatImage.tif") banda1 = srcArray[0] gdalnumeric.SaveArray(banda1, "../dati/banda1Estratta.jpg", format="JPEG")
def main(shapefile_path, raster_path): # Load the source data as a gdalnumeric array srcArray = gdalnumeric.LoadFile(raster_path) # Also load as a gdal image to get geotransform # (world file) info srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() # Create an OGR layer from a boundary shapefile shapef = ogr.Open(shapefile_path) lyr = shapef.GetLayer( os.path.split(os.path.splitext(shapefile_path)[0])[1]) poly = lyr.GetNextFeature() # Convert the layer extent to image pixel coordinates minX, maxX, minY, maxY = lyr.GetExtent() ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) # Calculate the pixel size of the new image pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[ulY:lrY, ulX:lrX] # # EDIT: create pixel offset to pass to new image Projection info # xoffset = ulX yoffset = ulY print("Xoffset, Yoffset = ( %f, %f )" % (xoffset, yoffset)) # Create a new geomatrix for the image geoTrans = list(geoTrans) geoTrans[0] = minX geoTrans[3] = maxY # Map points to pixels for drawing the # boundary on a blank 8-bit, # black and white, mask image. points = [] pixels = [] geom = poly.GetGeometryRef() pts = geom.GetGeometryRef(0) for p in range(pts.GetPointCount()): points.append((pts.GetX(p), pts.GetY(p))) for p in points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) # Clip the image using the mask # clip = gdalnumeric.choose(mask, \ # (clip, 0)).astype(gdalnumeric.uint8) clip = gdalnumeric.choose(mask, (clip, 0)) real = np.zeros(clip.shape) for i in range(len(clip)): for j in range(len(clip[i])): val = clip[i][j].real if (val < -4): val = -4 real[i, j] = val dst_ds = gdal.GetDriverByName('GTiff').Create("hello86568.tif", 300, 300, 1, gdal.GDT_CFloat32) # dst_ds.SetGeoTransform([444720, 30, 0, 3751320, 0, -30]) raster = np.zeros(real.shape, dtype=np.float32) dst_ds.GetRasterBand(1).WriteArray(real) # Once we're done, close properly the dataset dst_ds = None # This image has 3 bands so we stretch each one to make them # visually brighter # for i in range(3): clip2 = stretch(clip) # Save new tiff # # EDIT: instead of SaveArray, let's break all the # SaveArray steps out more explicity so # we can overwrite the offset of the destination # raster # ### the old way using SaveArray # # gdalnumeric.SaveArray(clip, "OUTPUT.tif", format="GTiff", prototype=raster_path) # ### # # gtiffDriver = gdal.GetDriverByName('GTiff') # if gtiffDriver is None: # raise ValueError("Can't find GeoTiff Driver") # gtiffDriver.CreateCopy("beijing9.tif", # gdal_array.OpenArray(clip, prototype_ds=raster_path) # ) # real = np.zeros(clip.shape) # for i in range(len(clip)): # for j in range(len(clip[i])): # val = clip[i][j].real # real[i, j] = val # draw(real) # Save as an 8-bit jpeg for an easy, quick preview clip3 = clip2.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip3, "beijing.jpg", format="JPEG") # misc.imsave("beijing7.png", clip2) gdal.ErrorReset()
def main(shapefile_path, raster_path): # Load the source data as a gdalnumeric array srcArray = gdalnumeric.LoadFile(raster_path) # Also load as a gdal image to get geotransform # (world file) info srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() # Create an OGR layer from a boundary shapefile shapef = ogr.Open(shapefile_path) lyr = shapef.GetLayer( os.path.split(os.path.splitext(shapefile_path)[0])[1]) poly = lyr.GetNextFeature() # Convert the layer extent to image pixel coordinates minX, maxX, minY, maxY = lyr.GetExtent() ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) # Calculate the pixel size of the new image pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[:, ulY:lrY, ulX:lrX] # # EDIT: create pixel offset to pass to new image Projection info # xoffset = ulX yoffset = ulY print "Xoffset, Yoffset = ( %f, %f )" % (xoffset, yoffset) # Create a new geomatrix for the image geoTrans = list(geoTrans) geoTrans[0] = minX geoTrans[3] = maxY # Map points to pixels for drawing the # boundary on a blank 8-bit, # black and white, mask image. points = [] pixels = [] geom = poly.GetGeometryRef() pts = geom.GetGeometryRef(0) for p in range(pts.GetPointCount()): points.append((pts.GetX(p), pts.GetY(p))) for p in points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new("L", (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) # Clip the image using the mask clip = gdalnumeric.choose(mask, \ (clip, 0)).astype(gdalnumeric.uint8) # This image has 3 bands so we stretch each one to make them # visually brighter for i in range(3): clip[i, :, :] = stretch(clip[i, :, :]) # Save new tiff # # EDIT: instead of SaveArray, let's break all the # SaveArray steps out more explicity so # we can overwrite the offset of the destination # raster # ### the old way using SaveArray # # gdalnumeric.SaveArray(clip, "OUTPUT.tif", format="GTiff", prototype=raster_path) # ### # gtiffDriver = gdal.GetDriverByName('GTiff') if gtiffDriver is None: raise ValueError("Can't find GeoTiff Driver") gtiffDriver.CreateCopy( "beijing.tif", OpenArray(clip, prototype_ds=raster_path, xoff=xoffset, yoff=yoffset)) # Save as an 8-bit jpeg for an easy, quick preview clip = clip.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip, "beijing.jpg", format="JPEG") gdal.ErrorReset()
def process_a_file(shapefile_path, raster_path, outdir, clip_size=448, avg_tree_rds=40): shapef = ogr.Open(shapefile_path) lyrname = os.path.split(os.path.splitext(shapefile_path)[0])[1] lyr = shapef.GetLayer(lyrname) srcImage = gdal.Open(raster_path) geoTrans = srcImage.GetGeoTransform() oriHei = srcImage.RasterYSize oriWid = srcImage.RasterXSize srcArray = gdalnumeric.LoadFile(raster_path) feat = lyr.GetNextFeature() geoPts = [] while feat is not None: geopt = feat.GetGeometryRef() geoPts.append([geopt.GetX(), geopt.GetY()]) feat = lyr.GetNextFeature() out_filename = outdir + lyrname + '_clip_label.txt' out_file = open(out_filename, 'a') for i, geopt in enumerate(geoPts): lyr.ResetReading() imgX, imgY = world2Pixel(geoTrans, geopt[0], geopt[1]) #imgPts.append([imgX, imgY]) ob_box = [ imgX - avg_tree_rds, imgY - avg_tree_rds, imgX + avg_tree_rds, imgY + avg_tree_rds ] #ob_boxes.append(ob_box) bnd_box = get_bndbox(ob_box, oriWid, oriHei) crop = random_crop(oriWid, oriHei, bnd_box, clip_size) geoUl = pixel2World(geoTrans, crop[0], crop[1]) geoBr = pixel2World(geoTrans, crop[2], crop[3]) lyr.SetSpatialFilterRect(geoUl[0], geoUl[1], geoBr[0], geoBr[1]) imgPts = [] ob_boxes = [] oFeature = lyr.GetNextFeature() while oFeature is not None: inRectPt = oFeature.GetGeometryRef() imgPt = world2Pixel(geoTrans, inRectPt.GetX(), inRectPt.GetY()) imgPts.append([imgPt[0], imgPt[1]]) ob_box = [ imgPt[0] - avg_tree_rds, imgPt[1] - avg_tree_rds, imgPt[0] + avg_tree_rds, imgPt[1] + avg_tree_rds ] ob_boxes.append(ob_box) oFeature = lyr.GetNextFeature() obs_str, center_str = find_all_objects_in_a_crop(crop, imgPts, avg_tree_rds, oriWid, oriHei, include_threshold=0.7) crop_name = outdir + lyrname + '/' + lyrname + '_ob{}_crop.jpg'.format( i) record = crop_name + obs_str out_file.write(record) # Save as an 8-bit jpeg for an easy, quick preview clip = srcArray[:, crop[1]:crop[3], crop[0]:crop[2]] clip = clip.astype(gdalnumeric.uint8) gdalnumeric.SaveArray(clip, crop_name, format="JPEG") out_file.close()
srcArray = gdalnumeric.LoadFile(raster) srcImage = gdal.Open(raster) geoTrans = srcImage.GetGeoTransform() r = shapefile.Reader('{}.shp'.format(shp)) minX, minY, maxX, maxY = r.bbox ulX, ulY = world2Pixel(geoTrans, minX, maxY) lrX, lrY = world2Pixel(geoTrans, maxX, minY) pxWidth = int(lrX - ulX) pxHeight = int(lrY - ulY) clip = srcArray[:, ulY:lrY, ulX:lrX] geoTrans = list(geoTrans) geoTrans[0] = minX geoTrans[3] = maxY pixels = [] for p in r.shape(0).points: pixels.append(world2Pixel(geoTrans, p[0], p[1])) rasterPoly = Image.new('L', (pxWidth, pxHeight), 1) rasterize = ImageDraw.Draw(rasterPoly) rasterize.polygon(pixels, 0) mask = imageToArray(rasterPoly) clip = gdalnumeric.numpy.choose(mask, (clip, 0)).astype(gdalnumeric.numpy.uint8) gdalnumeric.SaveArray(clip, '{}.tif'.format(output), format='GTiff', prototype=raster)