def image_offsets(img, coordinates): gt = img.GetGeoTransform() inv_gt = gdal.InvGeoTransform(gt) offsets_ul = list( map(int, gdal.ApplyGeoTransform(inv_gt, coordinates[0], coordinates[1]))) offsets_lr = list( map(int, gdal.ApplyGeoTransform(inv_gt, coordinates[2], coordinates[3]))) return offsets_ul + offsets_lr
def RasterOverlapToArray(file_list): UL_x_list = [] UL_y_list = [] LR_x_list = [] LR_y_list = [] for file in file_list: ds = gdal.Open(root_folder + file, gdal.GA_ReadOnly) gt = ds.GetGeoTransform( ) # UL_x, x-coordinate spatial resolution, UL_y, # y-coord. spat.res. # Upper left UL_x, UL_y = gt[0], gt[ 3] #calculate corner lat/lon coordinates (for x/y cell coordinates use inv_gt) UL_x_list.append(UL_x) UL_y_list.append(UL_y) # Lower right LR_x = UL_x + (gt[1] * ds.RasterXSize) LR_y = UL_y + (gt[5] * ds.RasterYSize) LR_x_list.append(LR_x) LR_y_list.append(LR_y) UL_x_ext = max(UL_x_list) #corner coordinates and extent of common extent UL_y_ext = min(UL_y_list) LR_x_ext = min(LR_x_list) LR_y_ext = max(LR_y_list) extent_x = int(round( (min(LR_x_list) - max(UL_x_list)) / gt[1])) #width of common extent/pixel width = number of columns extent_y = int( round(min(UL_y_list) - max(LR_y_list)) / gt[1]) #height of common extent/pixel height = number of rows overlap = [UL_x_ext, UL_y_ext, LR_x_ext, LR_y_ext] #only upper left and lower right coordinates print("Common extent UL/LR coordinates: ", overlap) print("Common extent in x and y direction: ", extent_x, extent_y) spat_res = [gt[1], abs(gt[5])] print("Common extent spatial resolution: ", spat_res, "\n") for file in file_list: #convert real-world coordinates (lat/lon) to image coordinates (x,y) print(file) #for overview in console ds = gdal.Open(root_folder + file, gdal.GA_ReadOnly) gt = ds.GetGeoTransform( ) # UL_x, x-coordinate spatial resolution, UL_y, # y-coord. spat.res. inv_gt = gdal.InvGeoTransform( gt) # transform geographic coordinates into array coordinates x1, y1 = gdal.ApplyGeoTransform(inv_gt, overlap[0], overlap[1]) x2, y2 = gdal.ApplyGeoTransform(inv_gt, overlap[2], overlap[3]) minX = int(round(min(x1, x2))) # x value for UL/origin minY = int(round(min(y1, y2))) # y value for UL/origin maxX = int(round(max(x1, x2))) # x value for LR maxY = int(round(max(y1, y2))) # y value for LR print("Cell coordinates of common extent: ", minX, maxX, minY, maxY) #cell coordinates of extent for each file x1off, y1off = map(int, [x1, y1]) #UL print("UL x offset: ", x1off) print("UL y offset: ", y1off, "\n") array_list.append(ds.ReadAsArray(x1off, y1off, extent_x, extent_y)) #Upper Left corner
def transbox(self, ds, bbox, topix=False, clip=False): ''' transform bounding box coordinates in lonlat to projected coordinates or pixel coordinates ''' src = osr.SpatialReference() src.ImportFromEPSG(4326) dest = osr.SpatialReference() dsproj = ds.GetProjection() dest.ImportFromWkt(dsproj) trans = osr.CoordinateTransformation(src, dest) x1, y1, x2, y2 = bbox ll = trans.TransformPoint(x1, y1) ul = trans.TransformPoint(x1, y2) lr = trans.TransformPoint(x2, y1) ur = trans.TransformPoint(x2, y2) x1 = min(ll[0], ul[0]) x2 = max(lr[0], ur[0]) y1 = min(ll[1], lr[1]) y2 = max(ul[1], ur[1]) if clip or topix: fwd = ds.GetGeoTransform() inv = gdal.InvGeoTransform(fwd) px1, py1 = gdal.ApplyGeoTransform(inv, x1, y1) px2, py2 = gdal.ApplyGeoTransform(inv, x2, y2) if py1 > py2: t = py1 py1 = py2 py2 = t if clip: px1 = int(max(0, px1)) py1 = int(max(0, py1)) px2 = int(min(ds.RasterXSize - 1, px2)) py2 = int(min(ds.RasterYSize - 1, py2)) if topix: x1 = px1 y1 = py1 x2 = px2 y2 = py2 else: x1, y1 = gdal.ApplyGeoTransform(fwd, px1, py1) x2, y2 = gdal.ApplyGeoTransform(fwd, px2, py2) if y1 > y2: return (x1, y2, x2, y1) else: return (x1, y1, x2, y2)
def pixel_to_point(self, pixel_x, pixel_y, geotransform): """Translates grid pixels coordinates to output projection points (using the geotransformation of the output projection)""" point_x, point_y = gdal.ApplyGeoTransform(geotransform, pixel_x, pixel_y) return point_x, point_y
def image_offsets(img, coordinates): ''' Function that calculates the image offsets from the upper left and lower right corners. :param img: :param coordinates: :return: ''' gt = img.GetGeoTransform() inv_gt = gdal.InvGeoTransform(gt) offsets_ul = list( map(int, gdal.ApplyGeoTransform(inv_gt, coordinates[0], coordinates[1]))) offsets_lr = list( map(int, gdal.ApplyGeoTransform(inv_gt, coordinates[2], coordinates[3]))) return offsets_ul + offsets_lr
def center_of_raster(self): geo_transform = self.raster.GetGeoTransform( ) # col, row ---> lon, lat x, y = gdal.ApplyGeoTransform(geo_transform, self.raster.RasterXSize / 2, self.raster.RasterYSize / 2) return x, y
def xy2lcc(name,lon_0,lat_0,x,y): radius = 6370e3 lcc_proj = pyproj.Proj(proj='lcc', lat_1=lat_0, lat_2=lat_0, lat_0=lat_0, lon_0=lon_0, a=radius, b=radius, towgs84='0,0,0', no_defs=True) print 'lcc:',lcc_proj.srs tif_proj = pyproj.Proj(projparams=proj_string(name)) print 'tif:',tif_proj.srs print 'ref:',ref_proj.srs ds=gdal.Open(name) xoffset, px_w, rot1, yoffset, rot2, px_h = ds.GetGeoTransform() posX = px_w * x + rot1 * y + xoffset posY = rot2 * x + px_h * y + yoffset gX, gY = gdal.ApplyGeoTransform(ds.GetGeoTransform(),x,y) print posX, posY print gX, gY posX += px_w / 2.0 posY += px_h / 2.0 print 'tif:', posX, posY lon, lat = pyproj.transform(tif_proj, ref_proj, posX, posY) print "ref lon lat:", lon, lat, deg2str(lon,0), deg2str(lat,1) lccX, lccY = pyproj.transform(ref_proj,lcc_proj,lon, lat) print "lcc x y:", lccX, lccY lcc2X, lcc2Y = pyproj.transform(tif_proj, lcc_proj, posX, posY) # different result? print "lcc2 x y:", lcc2X, lcc2Y lcc3X, lcc3Y = lcc_proj(lon, lat) print "lcc3 x y:", lcc3X, lcc3Y return lccX, lccY
def get_weights(self, ds, geom): fwd = ds.GetGeoTransform() _, inv = gdal.InvGeoTransform(fwd) x1, x2, y1, y2 = geom.GetEnvelope() px1, py1 = gdal.ApplyGeoTransform(inv, x1, y1) px2, py2 = gdal.ApplyGeoTransform(inv, x2, y2) if py2 < py1: t = py1 py1 = py2 py2 = t px1 = max(0, px1) py1 = max(0, py1) px2 = min(ds.RasterXSize, px2) py2 = min(ds.RasterYSize, py2) if px2 < px1 or py2 < py1: return [] weights = [] for y in range(int(py1), int(py2)): for x in range(int(px1), int(px2)): x1, y1 = gdal.ApplyGeoTransform(fwd, x, y) x2, y2 = gdal.ApplyGeoTransform(fwd, x + 1, y + 1) ring = ogr.Geometry(ogr.wkbLinearRing) ring.AddPoint(x1, y1) ring.AddPoint(x1, y2) ring.AddPoint(x2, y2) ring.AddPoint(x2, y1) ring.AddPoint(x1, y1) poly = ogr.Geometry(ogr.wkbPolygon) poly.AddGeometry(ring) if geom.Contains(poly): frac = 1.0 else: isect = poly.Intersection(geom) if isect.IsEmpty(): frac = 0.0 else: frac = isect.GetArea() / poly.GetArea() if frac != 0: weights.append([x, y, frac]) return weights
def pix2pos(ds, x, y): # position coordinates from geotiff pixel indices gt = ds.GetGeoTransform() xoffset, px_w, rot1, yoffset, rot2, px_h = gt posX, posY = gdal.ApplyGeoTransform(gt, x - 1, y - 1) # corner is (0,0) # move to centers of pixels # commented out, because gdalinfo does not # posX += px_w / 2.0 # posY += px_h / 2.0 return posX, posY
def point_to_pixel(self, point_x, point_y, inverse_geotransform): """Translates points from input projection (using the inverse transformation of the output projection) to the grid pixel coordinates in data array (zero start)""" # apply inverse geotranformation to convert to pixels pixel_x, pixel_y = gdal.ApplyGeoTransform(inverse_geotransform, point_x, point_y) return pixel_x, pixel_y
def get_px_coord(self, lon, lat): """ Convert lon-lat into x-y coordinates of pixel :param lon: longitude :param lat: latitude :return: tuple of pixel coordinates """ offsets_coord = gdal.ApplyGeoTransform(self.raster_inv_gt, lon, lat) px_x, px_y = map(int, offsets_coord) return px_x, px_y
def lonlat_to_pixel(lon, lat, inverse_geo_transform): """Translates the given lon, lat to the grid pixel coordinates in data array (zero start)""" wgs84_object = WGS84Transform() # transform to utm utm_x, utm_y, utm_z = wgs84_object.wgs84_to_utm(lon, lat) # apply inverse geo tranform pixel_x, pixel_y = gdal.ApplyGeoTransform(inverse_geo_transform, utm_x, utm_y) pixel_x = int(pixel_x) - 1 # adjust to 0 start for array pixel_y = int(pixel_y) - 1 # adjust to 0 start for array return pixel_x, abs(pixel_y) # y pixel is likly a negative value given geo_transform
def misc_8(): try: gdal.ApplyGeoTransform except: return 'skip' gt = (10, 0.1, 0, 20, 0, -1.0) res = gdal.ApplyGeoTransform(gt, 10, 1) if res != [11.0, 19.0]: return 'fail' return 'success'
def getcolrow(self, ds, lon, lat): proj = ds.GetProjection() src = osr.SpatialReference() src.ImportFromEPSG(4326) dest = osr.SpatialReference() dest.ImportFromWkt(proj) trans = osr.CoordinateTransformation(src, dest) x, y, z = trans.TransformPoint(lon, lat) inv = gdal.InvGeoTransform(ds.GetGeoTransform()) return gdal.ApplyGeoTransform(inv, x, y)
def subset(raster, subset, coordinates=True, multiband=False): """ Subsets a given raster to a set of coordinates [subset] into an array. When subset is given as list of geographic coordinates, they will be transformed to array indices. When subset is given as array indices, image will be subsetted. Indices must be in format [ulx, uly,lrx,lry] Bool-Arguments don't have to be specified, when called. Defaults to function definition. :param raster: :param subset: :param coordinates: :param multiband: :return array: """ if coordinates: gt = raster.GetGeoTransform() inv_gt = gdal.InvGeoTransform(gt) app_gt_offset_upperleft = gdal.ApplyGeoTransform( inv_gt, geo_overlap[0], geo_overlap[1]) app_gt_offset_lowerright = gdal.ApplyGeoTransform( inv_gt, geo_overlap[2], geo_overlap[3]) off_ulx, off_uly = map(int, app_gt_offset_upperleft) off_lrx, off_lry = map(int, app_gt_offset_lowerright) rows = off_lry - off_uly columns = off_lrx - off_ulx # idx = [off_ulx, off_uly, columns, rows ] array = raster.ReadAsArray(off_ulx, off_uly, columns, rows) return array else: idx = subset if gdal: array = raster.ReadAsArray(idx[0], idx[1], idx[2] - idx[0], idx[3] - idx[1]) else: if multiband: array = raster[:, idx[0]:idx[2], idx[1]:idx[3]] else: array = raster[idx[0]:idx[2], idx[1]:idx[3]] return array
def get_envelope(filepath): ds = gdal.Open(filepath, gdal.GA_ReadOnly) y,x = np.mgrid[:ds.RasterYSize:2j,:ds.RasterXSize:2j] bbox = np.array([gdal.ApplyGeoTransform(ds.GetGeoTransform(), xx, yy) for xx,yy in zip(x.ravel(), y.ravel())]) srs = osr.SpatialReference(wkt=ds.GetProjection()) geom = ogr.CreateGeometryFromWkt( 'POLYGON(({b[0][0]} {b[0][1]}, ' '{b[1][0]} {b[1][1]}, ' '{b[3][0]} {b[3][1]}, ' '{b[2][0]} {b[2][1]}, ' '{b[0][0]} {b[0][1]}))'.format(b=bbox), srs) return geom
def get_cached_value(self, filename, lon, lat): """ Get a single value at (lon,lat) from cache """ path = os.path.join(self.cache, filename) ds = gdal.OpenShared(path) fwd = ds.GetGeoTransform() inv = gdal.InvGeoTransform(fwd) # older versions of gdal have a different signature of InvGeoTransform() if inv and len(inv) == 2: _success, inv = inv x, y = gdal.ApplyGeoTransform(inv, lon, lat) x = int(max(0, min(ds.RasterXSize - 1, x))) y = int(max(0, min(ds.RasterYSize - 1, y))) value = ds.GetRasterBand(1).ReadAsArray(x, y, 1, 1) return value[0][0]
def read_GPS_file(filename, inv_trans): all_data = [] with open(filename, 'r') as f: for line in f.readlines(): vals = line.split(',') if line[:6] == '$GPGGA' and len(vals) > 10: lat_str, _, lon_str, _ = vals[2:6] lat = str_to_coord(lat_str) lon = -str_to_coord(lon_str) #W = negative, generalize later x, y, _, _ = utm.from_latlon(lat, lon) all_data.append((x, y)) ASV_X = [] ASV_Y = [] for x, y in all_data: row, col = gdal.ApplyGeoTransform(inv_trans, x, y) ASV_X.append(row) ASV_Y.append(col) return np.asarray(ASV_X), np.asarray(ASV_Y)
def read_mission_file(filename, inv_trans): coords = [] with open(filename, 'r') as f: for line in f.readlines(): if line[-1] == '\n': line = line[:-1] coords.append(list(map(float, line.split(',')))) X_all = [] Y_all = [] R = [] C = [] for lat, lon in coords: x, y, _, _ = utm.from_latlon(lat, lon) row, col = gdal.ApplyGeoTransform(inv_trans, x, y) X_all.append(x) Y_all.append(y) R.append(row) C.append(col) return X_all, Y_all, R, C
def geogrid_index(self): """ Geolocation in a form suitable for geogrid index. :return: dictionary key:value """ # spacing dx,dy = self.gt[1],self.gt[5] # known points in the center of the array (mass-staggered mesh from 1 at origin) known_x = (self.nx+1)/2. known_y = (self.ny+1)/2. # known points in the center of the array (unstaggered mesh from 0 at origin) known_x_uns = known_x-.5 known_y_uns = known_y-.5 # get pyproj element for reference lat-long coordinates ref_proj = self.pyproj.to_latlong() # lat/lon known points posX, posY = gdal.ApplyGeoTransform(self.gt,known_x_uns,known_y_uns) known_lon,known_lat = pyproj.transform(self.pyproj,ref_proj,posX,posY) # print center lon-lat coordinates to check with gdalinfo if not self.resampled: logging.info('GeoTIFF.geogrid_index - center lon/lat coordinates using pyproj.transform: %s' % coord2str(known_lon,known_lat)) logging.info('GeoTIFF.geogrid_index - center lon/lat coordinates using gdal.Info: %s' % gdal.Info(self.ds).split('Center')[1].split(') (')[1].split(')')[0]) # row order depends on dy if dy > 0: row_order = 'bottom_top' else: row_order = 'top_bottom' # write geogrid index return Dict({'projection' : self.projwrf, 'dx' : dx, 'dy' : dy, 'truelat1' : self.crs.GetProjParm("standard_parallel_1"), 'truelat2' : self.crs.GetProjParm("standard_parallel_2"), 'stdlon' : self.crs.GetProjParm("longitude_of_center",self.crs.GetProjParm("central_meridian",self.crs.GetProjParm("longitude_of_origin"))), 'known_x' : known_x, 'known_y' : known_y, 'known_lon' : known_lon, 'known_lat' : known_lat, 'row_order' : row_order })
def get_value_at_position(self, lat, lon, raster_band=1): band = self.ds.GetRasterBand(raster_band) bandtype = gdal.GetDataTypeName(band.DataType) px, py = gdal.ApplyGeoTransform(self.transfInv, lon, lat) if px > self.cols or py > self.rows: return None structval = band.ReadRaster(int(px), int(py), 1, 1, buf_type=band.DataType) fmt = self._pt2fmt(band.DataType) value = struct.unpack(fmt, structval) if value[0] == band.GetNoDataValue(): if fmt == 'f': return float('nan') else: return None else: result = value[0] return value[0]
def update_GPS(self): '''Get local x, y coordinate from robot. Then convert to utm for graphing''' x = self.controller.robot.state_est.x y = self.controller.robot.state_est.y # print('x,y: ', x, y) if self.controller.mode == "SIM MODE": heading = self.controller.robot.state_est.theta / math.pi * 180 else: heading = self.controller.robot.state_est.theta # Convert local x y to lat lon if x <= 0: lat = 0.0 lon = 0.0 else: lat, lon = utm.to_latlon(x, y, 11, 'S') self.gps['text'] = 'Latitude: ' + str(lat) + '\nLongitude: ' + str( lon) + '\nHeading: ' + str(round(heading, 2)) # Convert UTM to graphing row and column img_col, img_row = gdal.ApplyGeoTransform(self.inv_trans, x, y) row = int(img_row * MAP_HEIGHT / IMAGE_HEIGHT) col = int(img_col * MAP_WIDTH / IMAGE_WIDTH) # Update ASV location on map self.draw_arrow(col, row, heading * np.pi / 180.) self.gps_local['text'] = 'x: ' + str( col - self.origin_coords[0]) + ', y: ' + str(-row + self.origin_coords[1]) if self.goto_coords[0] != -1: self.control_wp_dxdy['text'] = 'dx: ' + str( int(self.goto_coords[0] - x)) + ', dy: ' + str( int(self.goto_coords[1] - y)) # Add border if self.set_border_mode: self.border_markers.append(self.draw_circle( col, row, border=True)) #TODO: make this more elegant?
def convertChartListGDAL(chartlist): for chart in chartlist: dataset = gdal.Open(chart, gdal.GA_ReadOnly) if dataset is None: warn("gdal cannot handle file " + chart) continue else: log("chart " + chart + " succcessfully opened") inosr = osr.SpatialReference() outosr = osr.SpatialReference() llosr = osr.SpatialReference() outosr.SetWellKnownGeogCS("WGS84") inosr.ImportFromWkt(dataset.GetProjection()) if not inosr.IsSameGeogCS(outosr): warn(chart + " is not in WGS84, cannot convert") continue llosr.CopyGeogCSFrom(inosr) transformer = osr.CoordinateTransformation(inosr, llosr) if transformer.this is None: warn( chart + " seems not to have a coordinate system, cannot transform (potentially missing some files)" ) continue geotr = dataset.GetGeoTransform() (ullon, ullat, z) = transformer.TransformPoint(geotr[0], geotr[3], 0) (lrlon, lrlat) = gdal.ApplyGeoTransform(geotr, dataset.RasterXSize, dataset.RasterYSize) log("raster: ullat=%f ullon=%f lrlat=%f lrlon=%f" % (geotr[3], geotr[0], lrlat, lrlon)) (lrlon, lrlat, z) = transformer.TransformPoint(lrlon, lrlat, 0) cmd = "%s %s %f %f %f %f" % (imgkap(), chart, ullat, ullon, lrlat, lrlon) log("running " + cmd) os.system(cmd)
def visible_region(self, geo_x=None, geo_y=None, width=None, height=None, scale=None): if self.raster is None: return if geo_x is None: geo_x = self.geo_x if geo_y is None: geo_y = self.geo_y if width is None: width = self.width() if height is None: height = self.height() if scale is None: scale = self.scale assert geo_x is not None and geo_y is not None geo_transform = self.raster.GetGeoTransform( ) # col, row ---> lon, lat ok, inverse_geo_transform = gdal.InvGeoTransform( geo_transform) # lon, lat ---> col, row col, row = gdal.ApplyGeoTransform(inverse_geo_transform, self.geo_x, self.geo_y) # col, row are now where we are centered in the image # I want scale=1 to be viewing the image at 1m per pixel. # The image may be sampled at a different resolution, fetch the meters-per-pixel from the geo-transform # Also, the pixels generally are not square. meters_x = geo_transform[1] meters_y = geo_transform[5] # Determine the size and offset within the raster x_size = abs(int(width * meters_x / scale)) y_size = abs(int(height * meters_y / scale)) x_off = int(col - x_size / 2) y_off = int(row - y_size / 2) return x_off, y_off, x_size, y_size
def __init__(self, controller): # Load map for display/GPS conversions dataset = gdal.Open(MAP_FILE) data = dataset.ReadAsArray() self.geo_trans = dataset.GetGeoTransform() self.inv_trans = gdal.InvGeoTransform(self.geo_trans) # Control parameters self.robot_stopped = True self.quit_gui = False self.mission_wps = [] #format [(lat, lon)...] ####################################################################### # GUI SECTION ####################################################################### # Set up GUI self.controller = controller self.tk = Tk() self.tk.report_callback_exception = handle_exception self.tk.title("ASV Control Interface") self.tk.protocol("WM_DELETE_WINDOW", self.on_quit) # GUI marker variables (labels on map) # Go to location self.goto_coords = (-1, -1) #UTM! #TODO: CURRENTLY NOT CHANGED self.location_select_mode = False self.cur_pos_marker = None self.target_pos_marker = None # Mission planning self.add_wps_mode = False self.remove_wps_mode = False self.running_mission_mode = False self.transect_mode = False # self.repeat_mission_mode = False self.set_border_mode = False self.wp_markers = [] self.wp_labels = [] self.border_markers = [] # Origin setting self.origin_coords = (0, 0) #pixel coords x, y = gdal.ApplyGeoTransform(self.geo_trans, 0, 0) print('Origin UTM:', x, y) self.set_origin_mode = False # Frames: Sidebar + Map Area self.sidebar_frame = Frame(self.tk, width=500, relief='sunken', borderwidth=2) self.map_frame = Frame(self.tk) self.sidebar_frame.pack(expand=True, fill='both', side='left', anchor='nw') self.map_frame.pack(expand=True, fill='both', side='right') ####################################################################### # SIDEBAR FRAME ####################################################################### # GPS Coordinates self.gps_title = Label(self.sidebar_frame, anchor='w', text='ASV GPS Information', font='Helvetica 14 bold').pack() self.gps = Label(self.sidebar_frame, anchor='w', width=30, text='Latitude: ???\nLongitude: ???\nHeading: ???') self.gps_local = Label(self.sidebar_frame, anchor='w', width=30, text='x: ???, y: ???') self.gps.pack() #self.gps_local.pack() # ADCP Data self.adcp_title = Label(self.sidebar_frame, anchor='w', text='ADCP Information', font='Helvetica 14 bold').pack() self.adcp_data = Label(self.sidebar_frame, anchor='w', width=30, text='Water depth: ???\nCurrent speed: ???') self.adcp_data.pack() # ASV Control Panel self.control_title = Label(self.sidebar_frame, anchor='w', text='ASV Control Panel', font='Helvetica 14 bold').pack() # 1) Go to map location # self.control_wp_dxdy = Label(self.sidebar_frame, anchor='w', width=30, text='dx: ???, dy: ???') # self.control_wp_dxdy.pack() self.auv_status = Label(self.sidebar_frame, anchor='w', text='ASV Status: STOPPED', fg="red") self.auv_status.pack() self.transect_mission_label = Label(self.sidebar_frame, anchor='w', text='Transect Mission: NO', fg="red") self.transect_mission_label.pack() self.transect_mission = Button(self.sidebar_frame, anchor='w', text='Enable Transect Mission', command=self.on_toggle_transect) self.transect_mission.pack() # Repeat mission (has been commented out because not useful) # self.repeat_mission_label = Label(self.sidebar_frame, anchor='w', text='Repeat Mission: NO', fg="red") # self.repeat_mission_label.pack() # self.repeat_frame = Frame(self.sidebar_frame) # self.repeat_frame.pack() # self.repeat_label = Label(self.repeat_frame, anchor='w', text='# Repeats').pack(side='left') # self.repeat_times = Entry(self.repeat_frame, width=5) # self.repeat_times.insert(END, '10') # self.repeat_times.pack(side='right') # self.repeat_mission = Button(self.sidebar_frame, anchor='w', text='Enable Repeat Mission', command=self.on_toggle_repeat_mission) # self.repeat_mission.pack() self.start_frame = Frame(self.sidebar_frame) self.start_frame.pack() self.start_stop = Button(self.start_frame, anchor='w', text='Start ASV', command=self.on_startstop) self.start_stop.pack(side='left') self.mission = Button(self.start_frame, anchor='w', text='Start Mission', command=self.on_toggle_mission) self.mission.pack(side='right') # 2) Mission planning self.mission_title = Label(self.sidebar_frame, anchor='w', text='Mission Planning', font='Helvetica 14 bold').pack() self.mission_disclaimer = Label( self.sidebar_frame, anchor='w', text= 'Red=Point Tracking(1), Orange=Transect(2).\nClick on WP in map to change color.', font='Helvetica 10 italic').pack() self.mission_frame = Frame(self.sidebar_frame) self.scrollbar = Scrollbar(self.mission_frame) self.scrollbar.pack(side='right') self.w_name = Label(self.mission_frame, text='') self.wp_list = Listbox(self.mission_frame, width=30, height=12, yscrollcommand=self.scrollbar.set) self.wp_list.pack(side='left') self.wp_list.bind('<<ListboxSelect>>', self.on_waypoint_selection) self.scrollbar.config(command=self.wp_list.yview) self.mission_frame.pack() self.mission_file_frame = Frame(self.sidebar_frame) self.mission_file_frame.pack() self.load_mission = Button( self.mission_file_frame, anchor='w', text='Load Mission File', command=self.on_load_mission).pack(side='left') self.save_mission = Button( self.mission_file_frame, anchor='w', text='Save Mission to File', command=self.on_save_mission).pack(side='right') self.mission_add_wps = Button(self.sidebar_frame, anchor='w', text='Add Waypoints', command=self.on_toggle_add_wps) self.mission_add_wps.pack() self.mission_remove_wps = Button(self.sidebar_frame, anchor='w', text='Remove Waypoints', command=self.on_toggle_remove_wps) self.mission_remove_wps.pack() self.clear_wps = Button(self.sidebar_frame, anchor='w', text='Clear All Waypoints', command=self.on_clear_wps) self.clear_wps.pack() ####################################################################### # MAP CANVAS ####################################################################### # Load map image pilImg = Image.open(MAP_FILE) pilImg = pilImg.resize((MAP_WIDTH, MAP_HEIGHT), Image.ANTIALIAS) self.img = ImageTk.PhotoImage(pilImg) # map self.canvas = Canvas(self.map_frame, width=MAP_WIDTH, height=MAP_HEIGHT) self.canvas.create_image(0, 0, image=self.img, anchor=NW) self.canvas.pack(side='top') self.canvas.bind("<Button 1>", self.on_location_click) self.origin_marker1 = self.canvas.create_line( 0, -10, 0, 10, fill='black', width=2) #to create a cross self.origin_marker2 = self.canvas.create_line(-10, 0, 10, 0, fill='black', width=2) ####################################################################### # CONFIGURATION FRAME ####################################################################### self.control_config_frame = Frame(self.map_frame, height=15) self.control_config_frame.pack(side='left') self.misc_frame = Frame(self.map_frame) self.misc_frame.pack(side='right') self.border_frame = Frame(self.misc_frame, height=15) self.border_frame.pack(side='top') self.compass_frame = Frame(self.misc_frame, height=15) self.compass_frame.pack(side='bottom') # Tracing border self.border_label = Label(self.border_frame, anchor='w', text='Border Configuration', font='Helvetica 14 bold').pack() self.border = Button(self.border_frame, anchor='w', text='Trace Border', command=self.on_toggle_border) self.border.pack() self.clear_border = Button(self.border_frame, anchor='w', text='Clear Border', command=self.on_clear_border).pack() self.load_border = Button(self.border_frame, anchor='w', text='Load Border', command=self.on_load_border).pack() self.save_border = Button(self.border_frame, anchor='w', text='Save Border', command=self.on_save_border).pack() # Compass calibration self.compass_label = Label(self.compass_frame, anchor='w', text='Compass Calibration', font='Helvetica 14 bold').pack() self.heading_frame = Frame(self.compass_frame) self.heading_frame.pack() self.heading_offset_label = Label( self.heading_frame, anchor='w', text='Heading Offset (deg)').pack(side='left') self.heading_offset = Entry(self.heading_frame, width=6) self.heading_offset.insert(END, '-12') self.heading_offset.pack(side='right') self.set_heading_offset = Button( self.compass_frame, anchor='w', text='Set Heading Offset', command=self.on_set_heading_offset).pack() # Control parameters/speed self.control_config = Label(self.control_config_frame, anchor='w', text='Control', font='Helvetica 14 bold').pack() self.control_info = Label(self.control_config_frame, anchor='w', text='ASV Speed: ?\n Speed to Dest: ?\n', fg="red") self.control_info.pack() # self.origin = Button(self.sidebar_frame, anchor='w', text='Set Map Origin', command=self.on_toggle_set_origin) # self.origin.pack() self.speed_frame = Frame(self.control_config_frame) self.speed_frame.pack() # self.set_desired_speed = Button(self.speed_frame, anchor='w', text='Set Desired Speed', command=self.on_set_desired_speed) # self.set_desired_speed.pack() # self.desired_speed_label = Label(self.speed_frame, anchor='w', text='Desired Speed (m/s)').pack(side='left') # self.desired_speed = Entry(self.speed_frame, width=10) # self.desired_speed.insert(END, '3') # self.desired_speed.bind('<Return>', self.on_set_desired_speed) # self.desired_speed.pack(side='right') ####################################################################### # Point Tracking Parameters ####################################################################### self.Kp_frame = Frame(self.control_config_frame) self.Kp_frame.pack() self.Kp_ang_label = Label(self.Kp_frame, anchor='w', text='K_ang').pack(side='left') self.Kp_ang = Entry(self.Kp_frame, width=5) self.Kp_ang.insert(END, '800') self.Kp_ang.pack(side='left') self.Kp_nom_label = Label(self.Kp_frame, anchor='w', text='K_nom').pack(side='left') self.Kp_nom = Entry(self.Kp_frame, width=5) self.Kp_nom.insert(END, '1000') self.Kp_nom.pack(side='left') self.K_vi_label = Label(self.Kp_frame, anchor='w', text='K_vi').pack(side='left') self.K_vi = Entry(self.Kp_frame, width=5) self.K_vi.insert(END, '0') self.K_vi.pack(side='left') ####################################################################### # Transect Parameters ####################################################################### self.transect_frame1 = Frame(self.control_config_frame) self.transect_frame1.pack() self.K_v_label = Label(self.transect_frame1, anchor='w', text='K_v').pack(side='left') self.K_v = Entry(self.transect_frame1, width=5) self.K_v.insert(END, '0.5') self.K_v.pack(side='left') self.K_latAng_label = Label(self.transect_frame1, anchor='w', text='K_latAng').pack(side='left') self.K_latAng = Entry(self.transect_frame1, width=5) self.K_latAng.insert(END, '0.5') self.K_latAng.pack(side='left') self.K_vert_label = Label(self.transect_frame1, anchor='w', text='K_vert').pack(side='left') self.K_vert = Entry(self.transect_frame1, width=5) self.K_vert.insert(END, '1000') self.K_vert.pack(side='left') self.transect_frame2 = Frame(self.control_config_frame) self.transect_frame2.pack() self.v_rate_label = Label(self.transect_frame2, anchor='w', text='v_rate').pack(side='left') self.v_rate = Entry(self.transect_frame2, width=5) self.v_rate.insert(END, '5') self.v_rate.pack(side='left') self.a_rate_label = Label(self.transect_frame2, anchor='w', text='a_rate').pack(side='left') self.a_rate = Entry(self.transect_frame2, width=5) self.a_rate.insert(END, '5') self.a_rate.pack(side='left') self.vx_des_label = Label(self.transect_frame2, anchor='w', text='vx_des').pack(side='left') self.vx_des = Entry(self.transect_frame2, width=5) self.vx_des.insert(END, '1') self.vx_des.pack(side='left') ####################################################################### # Throttle Thresholds ####################################################################### self.throttle_frame = Frame(self.control_config_frame) self.throttle_frame.pack() self.fwd_limit_frame = Frame(self.throttle_frame) self.fwd_limit_frame.pack(side='left') self.fwd_limit_label = Label(self.fwd_limit_frame, anchor='w', text='Fwd Limit').pack(side='left') self.fwd_limit = Entry(self.fwd_limit_frame, width=5) self.fwd_limit.insert(END, '1000') self.fwd_limit.pack(side='right') self.bwd_limit_frame = Frame(self.throttle_frame) self.bwd_limit_frame.pack(side='right') self.bwd_limit_label = Label(self.bwd_limit_frame, anchor='w', text='Bwd Limit').pack(side='left') self.bwd_limit = Entry(self.bwd_limit_frame, width=5) self.bwd_limit.insert(END, '1000') self.bwd_limit.pack(side='right') self.set_control_params = Button(self.control_config_frame, anchor='w', text='Set Control Params', command=self.on_set_control).pack()
def CoordToIndex(geoTransform, x, y): """Return the offset of the provided co-ordinate from origin of raster""" invGeotransform = gdal.InvGeoTransform(geoTransform) x1, y1 = gdal.ApplyGeoTransform(invGeotransform, x, y) columnPosition, RowPosition = int(x1), int(y1) return (columnPosition, RowPosition)
def rasterise_vector(raster_fname, vector_fname, where_statement=None, output_fname="", output_format="MEM", verbose=False): """Rasterises a vector file to produce a mask where some condition in the vector dataset is true. The mask will have the same extent and projection as a (provided) 'master' dataset. The selection of the feature for the mask will be performed by a command of the form field_name='Value', where the single quotes are mandatory (e.g. NAME='Ireland'). Parameters ----------- raster_fname: str A GDAL-compatible raster filename that will be used to extract the shape, projection, resolution, ... for the rasterisation. vector_fname: str The vector filename (e.g. Shapefile) where_statement: str The where statement (e.g. "NAME='Colombia'"). output_fname: str, optinal The output filename, if not provided, an "in-memory array" will be selected. If not provided and the output_format is other than `MEM` an error will be raised. output_format: str, optional An output format. By default, `MEM` verbose: Boolean Whether to get some extra inforamation Returns -------- The mask as a Numpy array, 0 where the mask is off, 1 where it is on. """ if output_fname == "" and output_format != "MEM": raise ValueError("You need to provide an ouput filename" + " for format{:s}".format(output_format)) g = gdal.Open(raster_fname) if g is None: raise IOError("Could not open file {:s}".format(raster_fname)) raster_proj = g.GetProjectionRef() geoT = g.GetGeoTransform() if verbose: print(">>> Opened file {:s}".format(raster_fname)) print(">>> Projection: {:s}".format(raster_proj)) xs = [] ys = [] for x, y in [[0, 0], [0, g.RasterYSize], [g.RasterXSize, g.RasterYSize], [g.RasterXSize, 0]]: xx, yy = gdal.ApplyGeoTransform(geoT, x, y) xs.append(xx) ys.append(yy) extent = [min(xs), min(ys), max(xs), max(ys)] xRes = geoT[1] yRes = geoT[-1] nx = g.RasterXSize ny = g.RasterYSize if verbose: print(">>> File size {:d} rows, {:d} columns".format(nx, ny)) print(">>> UL corner: {:g}, {:g}".format(min(xs), max(ys))) src_ds = gdal.OpenEx(vector_fname) if src_ds is None: raise IOError("Can't read the vector file {}".format(vector_fname)) v = gdal.VectorTranslate('', src_ds, format='Memory', dstSRS=raster_proj, where=where_statement) gg = gdal.Rasterize(output_fname, v, format=output_format, outputType=gdal.GDT_Byte, xRes=xRes, yRes=yRes, where=where_statement, outputBounds=[min(xs), min(ys), max(xs), max(ys)], width=nx, height=ny, noData=0, burnValues=1) if gg is not None: if verbose: print("Done! {:d} non-zero pixels".format(gg.ReadAsArray().sum())) else: raise ValueError("Couldn't generate the mask. Check input parameters") return gg.ReadAsArray()
def main(): img, inv_trans, geo_trans, MAP_WIDTH, MAP_HEIGHT = load_map(map_file) #GPS DATA ASV_X, ASV_Y = read_GPS_file(GPS_file, inv_trans) num_measurements = len(ASV_X) #ADCP DATA Z = read_ADCP_file(depths_file, num_measurements) #Z = water depths min_depth = Z.min() #HEADINGS headings = read_heading_file(heading_file, num_measurements) #Normalize positions min_x = min(ASV_X) min_y = min(ASV_Y) X = [v - min_x for v in ASV_X] Y = [v - min_y for v in ASV_Y] max_x = max(X) max_y = max(Y) # Method 0: 1D Kalman Filter m = int(np.ceil(max_x / CELL_RES)) n = int(np.ceil(max_y / CELL_RES)) baseFloor = min_depth B = baseFloor * np.ones((m, n)) Bvar = np.zeros((m, n)) for t in range(num_measurements): cur_x = X[t] cur_y = Y[t] cur_alt = Z[t] i = int(np.floor(cur_x / CELL_RES)) j = int(np.floor(cur_y / CELL_RES)) for k in range(max(0, i - win), min(m, i + win)): for l in range(max(0, j - win), min(n, j + win)): dist2 = 0.1 + CELL_RES * ((k - i)**2 + (l - j)**2)**0.5 if B[k][l] == baseFloor: B[k][l] = cur_alt Bvar[k][l] = (dist2 * sigma_slope + sigma_offset)**2 else: var = (dist2 * sigma_slope + sigma_offset)**2 cur_K = float(Bvar[k][l]) / (Bvar[k][l] + var) B[k][l] = B[k][l] + cur_K * (cur_alt - B[k][l]) Bvar[k][l] = Bvar[k][l] - cur_K * Bvar[k][l] # Method 1: Linear Interpolation xi, yi = np.mgrid[ASV_X.min():ASV_X.max():1000j, ASV_Y.min():ASV_Y.max():1000j] # Z is a matrix of x-y values points = [] for i in range(len(ASV_X)): points.append([ASV_X[i], ASV_Y[i]]) zi = griddata(points, Z, (xi, yi), method='linear') for i in range(len(zi)): for j in range(len(zi[0])): if np.isnan(zi[i][j]): zi[i][j] = min_depth ########################################################################### # PLOTS # 1) Map w/ ASV path imgplot = plt.imshow(img) plt.plot(ASV_X, ASV_Y, color='black', zorder=2) plt.xlabel('Meters') plt.ylabel('Meters') x0, y0 = gdal.ApplyGeoTransform(geo_trans, 0, 0) #UTM of top left corner x1, y1 = gdal.ApplyGeoTransform(geo_trans, 4000, 3000) print('Offsets', x1 - x0, y1 - y0) ax = plt.gca() # grab the current axis ax.set_xticks(np.arange(0, MAP_WIDTH + 500, 500)) # choose which x locations to have ticks xlabels = np.linspace(0, x1 - x0, int(MAP_WIDTH / 500.) + 1) xlabels = [int(p) for p in xlabels] ax.set_xticklabels(xlabels) # set the labels to display at those ticks ax.set_yticks(np.arange(0, MAP_HEIGHT, 500)) # choose which x locations to have ticks ylabels = np.linspace(0, y0 - y1, int(MAP_HEIGHT / 500.) + 1) ylabels = [int(p) for p in ylabels] ax.set_yticklabels(ylabels) # set the labels to display at those ticks #plt.contourf(xi, yi, zi, 10, cmap=plt.cm.rainbow, zorder=1) # 2) Depth surface map # B_new = np.zeros((n,m)) # for i in range(n): # for j in range(m): # B_new[i][j] = B[j][i] # X_plot, Y_plot = np.meshgrid(np.arange(m), np.arange(n)) # ax1 = plt.figure(figsize=(8,6)).gca(projection='3d') # surf = ax1.plot_surface(X_plot, Y_plot, B_new, cmap=cm.viridis) # p = ax1.plot(X, Y, np.zeros(len(X)), color='red') # ax1.view_init(200, -50) # ax1.set_zlabel('Depth (m)') # ax1.invert_zaxis() # ax1.set_xlabel('Easting (m)') # ax1.set_ylabel('Northing (m)') plt.show()
index = 0 for i in convexhulls: # 0 means read-only. 1 means writeable. vect_data_source = driver.Open(i, 0) # Get the Layer class object layer = vect_data_source.GetLayer(0) # Determine the spatial extent of the track # is a list with x_left, x_right, y_bottom, y_top extent = layer.GetExtent() print('vector extent is', extent) # Decide on the size of the buffer around the track buffer = 0.002 x1, y1 = gdal.ApplyGeoTransform(inv_gt, extent[0] - buffer, extent[2] - buffer) x2, y2 = gdal.ApplyGeoTransform(inv_gt, extent[1] + buffer, extent[3] + buffer) # round these indices, (especially when not using a buffer) # y indices increase from top to bottom!! #print('column numbers are', x1, x2, y1, y2) x1 = int(round(x1)) y1 = int(round(y1)) x2 = int(round(x2)) y2 = int(round(y2)) print(x1, x2, y1, y2) #print('column numbers are', x1, x2, y1, y2) # calculate how many rows and columns the ranges cover out_columns = x2 - x1 # y indices increase from top to bottom!!
def main(args): parser = argparse.ArgumentParser() parser.add_argument( '--input_geon', # default='../out_geon/D4_Curve_Geon.npy', type=str, help='input geon file.') parser.add_argument( '--input_dtm', # default='/dvmm-filer2/projects/Core3D/D4_Jacksonville/DTMs/D4_DTM.tif', type=str, help='Input dtm') # D3_UCSD D4_Jacksonville parser.add_argument( '--output_mesh', # default='../out_geon/D4_Curve_Mesh.ply', type=str, help='Output ply mesh file.') parser.add_argument( '--as-text', action='store_true', default=False, help='Output ply as ASCII instead of binary') args = parser.parse_args(args) original_dtm = gdal.Open(args.input_dtm, gdal.GA_ReadOnly) gt = original_dtm.GetGeoTransform() # captures origin and pixel size left = gdal.ApplyGeoTransform(gt, 0, 0)[0] top = gdal.ApplyGeoTransform(gt, 0, 0)[1] right = gdal.ApplyGeoTransform( gt, original_dtm.RasterXSize, original_dtm.RasterYSize)[0] bottom = gdal.ApplyGeoTransform( gt, original_dtm.RasterXSize, original_dtm.RasterYSize)[1] dtm = original_dtm.ReadAsArray() projection_model = {} projection_model['corners'] = [left, top, right, bottom] projection_model['project_model'] = gt projection_model['scale'] = 1.0 geon_model = [] all_vertex = [] all_face = [] center_of_mess, geon_model = pickle.load(open(args.input_geon, "rb")) for model in geon_model: if model['name'] == 'poly_cylinder': centroid, ex, ey, coefficients, min_axis_z,\ max_axis_z, ortho_x_min, ortho_x_max, fitted_indices_length, mean_diff = model[ 'model'] vertex, face = utils.get_poly_ply_volume(dtm, projection_model, centroid, ex, ey, coefficients, min_axis_z, max_axis_z, ortho_x_min, ortho_x_max, len(all_vertex), center_of_mess) if len(all_vertex) > 0: all_vertex.extend(vertex) all_face.extend(face) else: all_vertex = vertex all_face = face elif model['name'] == 'sphere': centroid, r, min_axis_z,\ max_axis_z, fitted_indices_length = model['model'] theta_max = get_theta(min_axis_z, r) theta_min = get_theta(max_axis_z, r) vertex, face = utils.get_sphere_volume(dtm, projection_model, centroid, r, theta_min, theta_max, len(all_vertex), center_of_mess) if len(all_vertex) > 0: all_vertex.extend(vertex) all_face.extend(face) else: all_vertex = vertex all_face = face for idx in range(len(all_vertex)): all_vertex[idx] = (all_vertex[idx][0]+center_of_mess[0], all_vertex[idx][1]+center_of_mess[1], all_vertex[idx][2]+center_of_mess[2]) all_vertex = np.array( all_vertex, dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')]) all_face = np.array(all_face, dtype=[( 'vertex_indices', 'i4', (3,)), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]) el_vertex = plyfile.PlyElement.describe(all_vertex, 'vertex') el_face = plyfile.PlyElement.describe(all_face, 'face') plyfile.PlyData([el_vertex, el_face], text=args.as_text).write(args.output_mesh)