def test_raster_what(self): res = gscript.raster_what(self.raster, [self.coords])[0] self.assertEquals(int(res[self.raster]['value']), 100) res = gscript.raster_what(self.raster, [self.coords], localized=True)[0] self.assertEquals(int(res[self.raster][_('value')]), 100)
def Query(self, x, y): """Query active layers from both mapwindows. :param x,y: coordinates """ rasters = ([layer.GetName() for layer in self.GetFirstMap().GetListOfLayers(ltype='raster', active=True)], [layer.GetName() for layer in self.GetSecondMap().GetListOfLayers(ltype='raster', active=True)]) vectors = ([layer.GetName() for layer in self.GetFirstMap().GetListOfLayers(ltype='vector', active=True)], [layer.GetName() for layer in self.GetSecondMap().GetListOfLayers(ltype='vector', active=True)]) if not (rasters[0] + rasters[1] + vectors[0] + vectors[1]): GMessage(parent=self, message=_('No raster or vector map layer selected for querying.')) return # set query snap distance for v.what at map unit equivalent of 10 pixels qdist = 10.0 * ((self.GetFirstMap().region['e'] - self.GetFirstMap().region['w']) / self.GetFirstMap().width) east, north = self.GetFirstWindow().Pixel2Cell((x, y)) # use display region settings instead of computation region settings self.tmpreg = os.getenv("GRASS_REGION") os.environ["GRASS_REGION"] = self.GetFirstMap().SetRegion(windres=False) result = [] if rasters[0]: result.extend(grass.raster_what(map=rasters[0], coord=(east, north), localized=True)) if vectors[0]: result.extend(grass.vector_what(map=vectors[0], coord=(east, north), distance=qdist)) if rasters[1]: result.extend(grass.raster_what(map=rasters[1], coord=(east, north), localized=True)) if vectors[1]: result.extend(grass.vector_what(map=vectors[1], coord=(east, north), distance=qdist)) self._QueryMapDone() result = PrepareQueryResults(coordinates=(east, north), result=result) if self._queryDialog: self._queryDialog.Raise() self._queryDialog.SetData(result) else: self._queryDialog = QueryDialog(parent=self, data=result) self._queryDialog.Bind(wx.EVT_CLOSE, self._oncloseQueryDialog) self._queryDialog.redirectOutput.connect(lambda output: self._giface.WriteLog(output)) self._queryDialog.Show()
def highestNeighbor(x, y, gscript, userid): # print out region for debugging purposes print "Finding points higher at ", x, y cell_res = config.getfloat(this_file, "cell_res") # meters. hard coded for now # r.what --v -f -n input=tile@grass64 east_north=-11796467.922180,4637784.666290 maxElevation = -1000 max_x = x max_y = y bndry = config.getint(this_file, "high_point_bndry") # (meters) # size of square to search for the peak value for i in range(-int(bndry / cell_res), int(bndry / cell_res)): for j in range(-int(bndry / cell_res), int(bndry / cell_res)): x_coor = x + i * cell_res y_coor = y + j * cell_res info = gscript.raster_what(options['demname'] + '@' + str(userid), [[x_coor, y_coor]]) info = info[0] info = info[info.keys()[0]] elevation = int(info['value']) if maxElevation < elevation: maxElevation = elevation max_x = x_coor max_y = y_coor return max_x, max_y
def Query(self, x, y): """Query active layers from both mapwindows. :param x,y: coordinates """ rasters = ( [layer.GetName() for layer in self.GetFirstMap().GetListOfLayers( ltype='raster', active=True)], [layer.GetName() for layer in self.GetSecondMap().GetListOfLayers( ltype='raster', active=True)]) vectors = ( [layer.GetName() for layer in self.GetFirstMap().GetListOfLayers( ltype='vector', active=True)], [layer.GetName() for layer in self.GetSecondMap().GetListOfLayers( ltype='vector', active=True)]) if not (rasters[0] + rasters[1] + vectors[0] + vectors[1]): GMessage( parent=self, message=_( 'No raster or vector map layer selected for querying.')) return # set query snap distance for v.what at map unit equivalent of 10 # pixels qdist = 10.0 * ( (self.GetFirstMap().region['e'] - self.GetFirstMap().region['w']) / self.GetFirstMap().width) east, north = self.GetFirstWindow().Pixel2Cell((x, y)) # use display region settings instead of computation region settings self.tmpreg = os.getenv("GRASS_REGION") os.environ["GRASS_REGION"] = self.GetFirstMap( ).SetRegion(windres=False) result = [] if rasters[0]: result.extend( grass.raster_what( map=rasters[0], coord=(east, north), localized=True)) if vectors[0]: result.extend( grass.vector_what( map=vectors[0], coord=(east, north), distance=qdist)) if rasters[1]: result.extend( grass.raster_what( map=rasters[1], coord=(east, north), localized=True)) if vectors[1]: result.extend( grass.vector_what( map=vectors[1], coord=(east, north), distance=qdist)) self._QueryMapDone() result = PrepareQueryResults(coordinates=(east, north), result=result) if self._queryDialog: self._queryDialog.Raise() self._queryDialog.SetData(result) else: self._queryDialog = QueryDialog(parent=self, data=result) self._queryDialog.Bind(wx.EVT_CLOSE, self._oncloseQueryDialog) self._queryDialog.redirectOutput.connect( lambda output: self._giface.WriteLog(output)) self._queryDialog.Show()
#type("x") #x = grass.raster_what('dgm', [[summit.read(s).x, summit.read(s).y]], env=None, localized=False) #hs = x[0]["dgm"]["value"] #hs = str(float(hs)+1) #print(hs) # Use maximum height in the vicinitiy of the actual summit grass.run_command("r.neighbors", input="dgm", output="dgm_maxfilter", method="maximum", size=31, overwrite=True) type("x") x = grass.raster_what('dgm_maxfilter', [[summit.read(s).x, summit.read(s).y]], env=None, localized=False) hs = x[0]["dgm_maxfilter"]["value"] hs = str(float(hs) + 1) print(hs) # Reclass dem # See e.g. https://grasswiki.osgeo.org/wiki/GRASS_Python_Scripting_Library # Version using reclass file: #rfile = tmppath + os.sep + "temp.txt" #with open(rfile, "w") as text_file: # text_file.write("%s thru 99999999999999999 = 1" % hs) #grass.run_command("r.reclass", input = "dgm", output = "dgm_reclass", rules = rfile, overwrite=True) # Version without reclass file grass.write_command("r.reclass",
def test_raster_what(self): res = gs.raster_what(self.raster, [self.coords])[0] self.assertEquals(int(res[self.raster]["value"]), 100) res = gs.raster_what(self.raster, [self.coords], localized=True)[0] self.assertEquals(int(res[self.raster][_("value")]), 100)
def main(): punti=options['points'] dem=options['dem'] TR=options['time'] outlet=options['outlets'] outlets = outlet.split(',') try: TR=int(TR) except: print 'TR is not a number' sys.exit() grass.use_temp_region() #test to access points new_points = VectorTopo(punti) if new_points.exist(): points_str=grass.read_command('v.to.db', map=punti,type='point',option='coor',flags='p') points_list = points_str.split('\n') points_list.remove('') else: print 'File %s does not exist' % punti sys.exit() #get region in order to estimate the threshold as 1/1000 of total cells grass.run_command('g.region',raster=dem) regione=grass.region() thrshold=float(regione['cells'])/300 #stream and drainage determination grass.run_command('r.watershed', elevation=dem, threshold=500, stream='raster_streams', drainage='drainage',overwrite=True,flags='s') #the radius is little more than the current resolution radius=regione['nsres']*1.4 output_points = [] ''' STARTIN CICLE ON EACH OUTLET IN LIST ''' category=1 for outlet in points_list[1:]: outlet = outlet.split('|')[1:-1] print ', '.join(outlet) grass.run_command('g.region',raster=dem) grass.run_command('r.circle', output='circle', coordinate=','.join(outlet), max=radius,overwrite=True) #get the distances and take the shortest distance distances=grass.read_command('r.distance', map='circle,raster_streams') list_dist=distances.split('\n') list_dist.remove('') list_tuple=[] for distance in list_dist: dist=distance.split(':') my_tupla=dist[0],dist[1],float(dist[2]),dist[3],dist[4],dist[5],dist[6] list_tuple.append(my_tupla) tuple_orderedByDistance=sorted(list_tuple, key=lambda distanza: distanza[2]) del(distances,list_tuple,list_dist) #calculate the basin and read its statistics outlet=tuple_orderedByDistance[0][-2:] xoutlet=float(outlet[0]) youtlet=float(outlet[1]) grass.run_command('r.water.outlet',input='drainage',output='basin',coordinates=str(xoutlet)+','+str(youtlet) , overwrite=True) statistics=grass.read_command('r.univar',map=dem, zones='basin') main_stat=statistics.splitlines()[-9:] #order the stream network grass.run_command('r.mask',raster='basin') grass.run_command('r.stream.order',stream_rast='raster_streams', direction='drainage', elevation=dem,horton='horton',overwrite=True) stream_stat=grass.read_command('r.stream.stats', stream_rast='horton', direction='drainage', elevation=dem,flags='o') network_statistics=stream_stat.split('\n') network_statistics.remove('') #get the max order network_statistics[-1].split() total_length=float(network_statistics[-1].split(',')[2]) area_basin=float(network_statistics[-1].split(',')[3]) area_basin_Ha=area_basin*100 mean_elev=float(main_stat[3].split(':')[-1]) min_elev=float(main_stat[0].split(':')[-1]) max_elev=float(main_stat[1].split(':')[-1]) deltaH=max_elev-min_elev average_slope=float(network_statistics[-1].split(',')[4]) grass.run_command('r.mask',flags='r') TcGiandotti=(4*np.sqrt(area_basin)+1.5*total_length)/(0.8*np.sqrt(mean_elev-min_elev)) TcKirpich=0.945*(total_length**3./deltaH)**0.385 if area_basin_Ha > 1000: #TODO controlla i riferimenti corrivazione = TcGiandotti grass.info('using giandotti') grass.info(str(TcGiandotti)) formula = 'Giandotti' else: corrivazione = TcKirpich formula = 'Kirpich' grass.info('using Kirpich') grass.info(str(TcKirpich)) if corrivazione < 24: aPar='a24@PERMANENT' bPar='b24@PERMANENT' kPar='k24@PERMANENT' else: aPar='a15@PERMANENT' bPar='b15@PERMANENT' kPar='k15@PERMANENT' CNmap = 'CN@PERMANENT' corrivazione=TcGiandotti aStat=grass.read_command('r.univar',map=aPar, zones='basin') aMain_stat=aStat.splitlines()[12].split(':')[-1] aMain_stat=float(aMain_stat) bStat=grass.read_command('r.univar',map=bPar, zones='basin') bMain_stat=bStat.splitlines()[12].split(':')[-1] bMain_stat=float(bMain_stat) kStat=grass.read_command('r.univar',map=kPar, zones='basin') kMain_stat=kStat.splitlines()[12].split(':')[-1] kMain_stat=float(kMain_stat) CNstat = grass.read_command('r.univar',map=CNmap, zones='basin') CN=CNstat.splitlines()[12].split(':')[-1] CN=float(CN) g.message('area basin in km2: ') print area_basin print 'mean elev: ' print mean_elev-min_elev print 'delta H:' print deltaH print 'total reach length: ' print total_length print 'a mean:' print aMain_stat print '\n b mean: ' print bMain_stat print '\n k mean: ' print kMain_stat print 'CN mean:' CN = 70.12/82.63 * CN print CN f_K_T = 1-kMain_stat*(0.45+0.799*np.log(-np.log(1-1./TR))) print 'f(k,T): ' print f_K_T h=f_K_T*aMain_stat*corrivazione**bMain_stat print '\n h main:' print h X1 = 100*corrivazione/(0.236+0.062*corrivazione) X2 = 0.003*corrivazione+0.0234 Pa = 100 - area_basin_Ha/(X1+X2*area_basin_Ha) Ha = h*Pa/100 new = VectorTopo('outlet') S1 = (1000./CN)-10 Pn = (Ha-5.08*S1)**2/(Ha+20.32*S1) Qc = (1/360.)*Pn*area_basin_Ha/corrivazione print 'discharge: ' print Qc #print table.columns.types() #[u'INTEGER', u'TEXT', u'integer', u'double precision'] ''' ------------------------------ START CALCULATION OF LOCAL UPSTREAM SLOPE ------------------------------ ''' #offsets for moving windows offsets = [d for j in xrange(1,1+1) for i in [j,-j] for d in [(i,0),(0,i),(i,i),(i,-i)]] #rename dtm as elevation for future calculation if not exist if not VectorTopo('elevation').exist(): grass.run_command('g.rename',raster="%s,elevation" % dem) elev_renamed=True #define drainage direction drainage_incoming = [2,4,3,1,6,8,7,5] drainage_outcoming = [] diag_dist= (regione['nsres']**2+regione['ewres']**2)**0.5 # [(1, 0), (0, 1), (1, 1), (1, -1), (-1, 0), (0, -1), (-1, -1), (-1, 1), cell_dists = [regione['nsres'], regione['ewres'], diag_dist, diag_dist, regione['nsres'], regione['ewres'], diag_dist, diag_dist ] # define the calculation term terms = ["(drainage[%d,%d] == %d && not(isnull(raster_streams[0,0])) && not(isnull(raster_streams[%d,%d])) )" % ((offsets[j]+tuple([drainage_incoming[j]])+offsets[j])) for j in range(len(drainage_incoming))] #define the operation expression terms_calc = [ "(elevation[%d,%d] - elevation) * %s" % (offsets[j]+(terms[j],) ) for j in range(len(terms))] terms_calc_slope = [ "( (elevation[%d,%d] - elevation)/%10.4f ) * %s" % (offsets[j]+(cell_dists[j],)+(terms[j],)) for j in range(len(terms))] expr = "num_cells_drain_into = (%s)" % " + ".join(terms) expr1 = "elevation_percentile4 = if(isnull(raster_streams),null(),(%s))" % " + ".join(terms) expr2 = "elevdiff_drain_into = %s" % " + ".join(terms_calc) expr3 = "slope_drain_into = %s" % " + ".join(terms_calc_slope) # do the r.mapcalc calculation with the moving window # exclude the num_cell_calculation_into #grass.mapcalc( expr ) #print expr2 #grass.mapcalc( expr2 , overwrite=True) #print expr3 grass.mapcalc( expr3 , overwrite=True) ''' ------------------------------ START CALCULATION OF 2KM UPSTREAM SLOPE ------------------------------ ''' #create an outlet vector new_outlet = VectorTopo('outlet') COLS = [(u'cat', 'INTEGER PRIMARY KEY')] new_outlet.open('w', tab_name='outlet', tab_cols=COLS) new_outlet.write(Point( xoutlet , youtlet ), cat=1, ) new_outlet.table.conn.commit() new_outlet.table.execute().fetchall() new_outlet.close() #find local main channel horton_order=grass.raster_what('horton', [[ xoutlet , youtlet ]]) horton_order = int( horton_order[0]['horton']['value'] ) print "Horton order for main channel:" print horton_order grass.run_command('g.region', zoom='horton') grass.mapcalc( "main_stream = if((horton == %d),1,null())" % horton_order, overwrite=True ) grass.run_command('r.to.vect', input='main_stream', output='main_stream', type='line',overwrite=True) grass.run_command('v.build.polylines', overwrite=True, input='main_stream', output='main_stream_poly', cats='first') #network analysis on main channel grass.run_command('v.net',input='main_stream_poly', points='outlet', output='main_stream_connected', operation='connect', threshold=radius*3,overwrite=True) grass.run_command('v.net.iso', input='main_stream_connected',output='main_stream_iso', center_cats=1, costs='100,200,400',overwrite=True) report=grass.read_command('v.category', input='main_stream_iso', option='report',type='line') min_max = report.split('\n')[3].split()[-2:] min_cat = int (min_max[0] ) max_cat = int (min_max[1] ) elev_outlet = grass.raster_what('elevation', [[ xoutlet , youtlet ]]) elev_outlet = float( elev_outlet[0]['elevation']['value'] ) drops = [] for i in range(min_cat,max_cat): grass.run_command('v.extract',input='main_stream_iso' ,type='line', cats=i, output='main_stream_%s' % i,overwrite=True) grass.run_command('v.to.points', input='main_stream_%s' % i,type='line', output='nodes',use='node',overwrite=True) points=grass.read_command('v.to.db',flags='p', map='nodes', type='point', option='coor', columns='x,y', layer=2) points=points.split('\n')[1:] points.remove('') elevations_drops = [] print points for point in points: xpoint = float ( point.split('|')[1] ) ypoint = float( point.split('|')[2] ) elev = grass.raster_what('elevation', [[ xpoint , ypoint ]]) elev = float( elev[0]['elevation']['value'] ) elevations_drops.append(elev-elev_outlet) elevations_drops.sort(reverse=True) drops.append(elevations_drops[0]) print 'list di drops:' print drops #sample the raster slope in the outlets slope_query=grass.raster_what('slope_drain_into', [[ xoutlet , youtlet ]]) slope = slope_query[0]['slope_drain_into']['value'] if slope == '0': slope = 1./10000 else: slope = float( slope ) dict_output = { 'xoutlet':xoutlet, 'youtlet':youtlet, 'cat':category, 'attrs':(Qc, slope, 9810.0*Qc*slope,total_length,elev_outlet,drops[0],drops[1],drops[2],drops[0]/100.,drops[1]/200.,drops[2]/400.,) } output_points.append(dict_output) print category category+=1 print category #cleaning part if elev_renamed: grass.run_command('g.rename',raster='elevation,%s' % dem) grass.del_temp_region() grass.run_command('g.remove',flags='f', type='raster', name='main_stream,basin,circle,drainage,horton,raster_streams,slope_drain_into') grass.run_command('g.remove',flags='f', type='vector', name='main_stream,nodes,outlet') grass.run_command('g.remove',type='vector',pattern='main_stream*',flags='f') #creation of output data container print output_points new = VectorTopo('output') COLS = [(u'cat', 'INTEGER PRIMARY KEY'), (u'discharge', u'double precision') , (u'local_upslope', u'double precision'), (u'TSP_local', u'double precision'), (u'ch_len', u'double precision'),(u'elev', u'double precision'), (u'drop100', u'double precision'), (u'drop200', u'double precision'), (u'drop400', u'double precision'), (u'upslope_100', u'double precision'), (u'upslope_200', u'double precision'),(u'upslope_400', u'double precision') ] new.open('w', tab_name='output', tab_cols=COLS) for elem in output_points: new.write(Point( elem['xoutlet'], elem['youtlet'] ), cat = elem['cat'], attrs=elem['attrs'] ) new.table.conn.commit() new.table.execute().fetchall() new.close()
from grass.pygrass.modules import Module summit = VectorTopo("summit", "PERMANENT", LOCATION_NAME="Kufstein") summit.open(mode='r') pointsList = [] for i in range(len(summit)): pointsList.append(summit.read(i + 1)) grass.run_command("r.neighbors", input="dgm", output="dgm_maxfilter", method="maximum", size=31) type("x") x = grass.raster_what('dgm_maxfilter', [[pointsList[0].x, pointsList[0].y]], env=None, localized=False) hs = x[0]["dgm_maxfilter"]["value"] hs = str(float(hs) + 1) print(hs) pointsList[0] type("x") x = grass.raster_what('dgm', [[pointsList[0].x, pointsList[0].y]], env=None, localized=False) hs = x[0]["dgm"]["value"] hs = str(float(hs) + 1) print(hs) grass.write_command("r.reclass",