def mkContours(self): """Make a contour map of the given DEM, in the given catchment""" # check what breaks to take, if int find nice breaks, if list take as breaks if type(self.contours) is int: interval = self.contours # get stats of DEM for nice breaks stats=grass.parse_command('r.univar',map=self.elevation,flags='g') # make nice breaks minelev = int(float(stats['min'])/interval+1)*interval maxelev = int(float(stats['max'])/interval)*interval breaks = range(minelev,maxelev+1,interval) else: breaks = self.contours if len(breaks)<2: grass.fatal('Need at least 2 contour breaks: %s \nRange of elevation: %s - %s' %(breaks,stats['min'],stats['max'])) grass.message(('Contour breaks:',str(breaks))) # form mapcalc expression and execute exp = self.contourrast+'= if(%s<%s,1)' %(self.elevation, breaks[0]) # for the first, smaller than for b in breaks: exp+='+ if(%s>=%s,1)' %(self.elevation,b) # for all greater eq than grass.mapcalc(exp, overwrite=True) grass.message(('Calculated contourmap: %s' %self.contourrast)) return
def main(): driver = UserSettings.Get(group = 'display', key = 'driver', subkey = 'type') if driver == 'png': os.environ['GRASS_RENDER_IMMEDIATE'] = 'png' else: os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo' first = options['first'] second = options['second'] mode = options['mode'] for mapName in [first, second]: if mapName: gfile = grass.find_file(name = mapName) if not gfile['name']: grass.fatal(_("Raster map <%s> not found") % mapName) app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = SwipeMapFrame(parent = None, giface = StandaloneGrassInterface()) if first: frame.SetFirstRaster(first) if second: frame.SetSecondRaster(second) if first or second: frame.SetRasterNames() frame.SetViewMode(mode) frame.Show() app.MainLoop()
def main(): options, unused = gscript.parser() input = options['input'] red = options['red'] green = options['green'] blue = options['blue'] if not gscript.find_file(input)['file']: gscript.fatal(_("Raster map <%s> not found") % input) expressions = [] maps = [] if red: expressions.append('%s = r#${input}' % red) maps.append(red) if green: expressions.append('%s = g#${input}' % green) maps.append(green) if blue: expressions.append('%s = b#${input}' % blue) maps.append(blue) expr = ';'.join(expressions) gscript.mapcalc(expr, input=input) for name in maps: gscript.run_command('r.colors', map=name, color='grey255') gscript.raster_history(name)
def get_table_name(map_name, layer): ### Test to make sure the vector has the correct layer - and get the table name from it try: table_name = grass.vector_layer_db(map_name, layer)['name'] except: grass.fatal("Map <%s> does not have layer number %s" % (map_name,layer)) return table_name
def main(): """ Compute cell areas """ projinfo = grass.parse_command('g.proj', flags='g') options, flags = grass.parser() output = options['output'] units = options['units'] # First check if output exists if len(grass.parse_command('g.list', type='rast', pattern=options['output'])): if not grass.overwrite(): grass.fatal("Raster map '" + options['output'] + "' already exists. Use '--o' to overwrite.") # Then compute if projinfo['units'] == 'meters': if units == 'm2': grass.mapcalc(output+' = nsres() * ewres()') elif units == 'km2': grass.mapcalc(output+' = nsres() * ewres() / 10.^6') elif projinfo['units'] == 'degrees': if units == 'm2': grass.mapcalc(output+' = ( 111195. * nsres() ) * \ ( ewres() * '+str(np.pi/180.)+' * 6371000. * cos(y()) )') elif units == 'km2': grass.mapcalc(output+' = ( 111.195 * nsres() ) * \ ( ewres() * '+str(np.pi/180.)+' * 6371. * cos(y()) )') else: print 'Units: ', + projinfo['units'] + ' not currently supported'
def read_sdf(input): """ Read the input SDF, scanning for lines with "CUT LINE" Read the coords from the next three lines, and save to list Read the bank postions from the following line and save to another list Return both lists """ with open(input, 'r') as sdf: lines = sdf.readlines() sdf.close() cutline_pts=[] bank_dist=[] for i in range(len(lines)): if 'CUT LINE' in lines[i]: coords1 = lines[i+1].strip().replace(" ", "").split(",") coords2 = lines[i+2].strip().replace(" ", "").split(",") coords3 = lines[i+3].strip().replace(" ", "").split(",") pt1 = [coords1[0],coords1[1]] pt2 = [coords2[0],coords2[1]] pt3 = [coords3[0],coords3[1]] cutline_pts.append([pt1,pt2,pt3]) if 'BANK POSITIONS' in lines[i+4]: coords=lines[i+4].strip().split(':')[1] bank_pt = coords.split(',') bank_dist.append(bank_pt) else: grass.fatal("No BANK POSITIONS data in sdf file") return None return cutline_pts, bank_dist
def create_db(driver, database): subst_database = substitute_db(database) if driver == 'dbf': path = subst_database # check if destination directory exists if not os.path.isdir(path): # create dbf database os.makedirs(path) return True return False if driver == 'sqlite': path = os.path.dirname(subst_database) # check if destination directory exists if not os.path.isdir(path): os.makedirs(path) if subst_database in grass.read_command('db.databases', quiet = True, driver = driver).splitlines(): return False grass.info(_("Target database doesn't exist, " "creating a new database using <%s> driver...") % driver) try: grass.run_command('db.createdb', driver = driver, database = subst_database) except CalledModuleError: grass.fatal(_("Unable to create database <%s> by driver <%s>") % \ (subst_database, driver)) return False
def main(): # Get the options input = options["input"] output = options["output"] method = options["method"] order = options["order"] where = options["where"] add_time = flags["t"] nulls = flags["n"] # Make sure the temporal database exists tgis.init() sp = tgis.open_old_stds(input, "strds") rows = sp.get_registered_maps("id", where, order, None) if rows: # Create the r.series input file filename = grass.tempfile(True) file = open(filename, 'w') for row in rows: string = "%s\n" % (row["id"]) file.write(string) file.close() flag = "" if len(rows) > 1000: grass.warning(_("Processing over 1000 maps: activating -z flag of r.series which slows down processing")) flag += "z" if nulls: flag += "n" try: grass.run_command("r.series", flags=flag, file=filename, output=output, overwrite=grass.overwrite(), method=method) except CalledModuleError: grass.fatal(_("%s failed. Check above error messages.") % 'r.series') if not add_time: # Create the time range for the output map if output.find("@") >= 0: id = output else: mapset = grass.gisenv()["MAPSET"] id = output + "@" + mapset map = sp.get_new_map_instance(id) map.load() map.set_temporal_extent(sp.get_temporal_extent()) # Register the map in the temporal database if map.is_in_db(): map.update_all() else: map.insert()
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.utils import _ from dbmgr.manager import AttributeManager mapName = gscript.find_file(options['map'], element='vector')['fullname'] if not mapName: gscript.set_raise_on_error(False) gscript.fatal(_("Vector map <%s> not found") % options['map']) app = wx.App() gscript.message(_("Loading attribute data for vector map <%s>...") % mapName) f = AttributeManager(parent=None, id=wx.ID_ANY, title="%s - <%s>" % (_("GRASS GIS Attribute Table Manager"), mapName), size=(900, 600), vectorName=mapName) f.Show() app.MainLoop()
def __init__(self, opt_output): self.cleanup_mask = False self.cleanup_layers = False # output map name self.opt_output = opt_output # suffix for existing mask (during overriding will be saved # into raster named:self.opt_output + this suffix) self.original_mask_suffix = "_temp_MASK" # check names of temporary rasters, which module may create maps = [] for suffix in (".red", ".green", ".blue", ".alpha", self.original_mask_suffix): rast = self.opt_output + suffix if grass.find_file(rast, element="cell", mapset=".")["file"]: maps.append(rast) if len(maps) != 0: grass.fatal( _( "Please change output name, or change names of these rasters: %s, " "module needs to create this temporary maps during execution." ) % ",".join(maps) )
def main(): # Get the options input = options["input"] where = options["where"] columns = options["columns"] tempwhere = options["t_where"] layer = options["layer"] separator = grass.separator(options["separator"]) if where == "" or where == " " or where == "\n": where = None if columns == "" or columns == " " or columns == "\n": columns = None # Make sure the temporal database exists tgis.init() sp = tgis.open_old_stds(input, "stvds") rows = sp.get_registered_maps("name,layer,mapset,start_time,end_time", tempwhere, "start_time", None) col_names = "" if rows: for row in rows: vector_name = "%s@%s" % (row["name"], row["mapset"]) # In case a layer is defined in the vector dataset, # we override the option layer if row["layer"]: layer = row["layer"] select = grass.read_command("v.db.select", map=vector_name, layer=layer, columns=columns, separator="%s" % (separator), where=where) if not select: grass.fatal(_("Unable to run v.db.select for vector map <%s> " "with layer %s") % (vector_name, layer)) # The first line are the column names list = select.split("\n") count = 0 for entry in list: if entry.strip() != "": # print the column names in case they change if count == 0: col_names_new = "start_time%send_time%s%s" % ( separator, separator, entry) if col_names != col_names_new: col_names = col_names_new print col_names else: if row["end_time"]: print "%s%s%s%s%s" % (row["start_time"], separator, row["end_time"], separator, entry) else: print "%s%s%s%s" % (row["start_time"], separator, separator, entry) count += 1
def _export_vector_maps(rows, tar, list_file, new_cwd, fs): for row in rows: name = row["name"] start = row["start_time"] end = row["end_time"] layer = row["layer"] # Export unique maps only if name in exported_maps: continue if not layer: layer = 1 if not end: end = start string = "%s:%s%s%s%s%s\n" % (name, layer, fs, start, fs, end) # Write the filename, the start_time and the end_time list_file.write(string) # Export the vector map with v.pack try: gscript.run_command("v.pack", input=name, flags="c") except CalledModuleError: shutil.rmtree(new_cwd) tar.close() gscript.fatal(_("Unable to export vector map <%s> with v.pack" % name)) tar.add(name + ".pack") exported_maps[name] = name
def get_extensions(): addon_base = os.getenv('GRASS_ADDON_BASE') if not addon_base: grass.fatal(_("%s not defined") % "GRASS_ADDON_BASE") fXML = os.path.join(addon_base, 'modules.xml') if not os.path.exists(fXML): return [] # read XML file fo = open(fXML, 'r') try: tree = etree.fromstring(fo.read()) except StandardError as e: grass.error(_("Unable to parse metadata file: %s") % e) fo.close() return [] fo.close() libgis_rev = grass.version()['libgis_revision'] ret = list() for tnode in tree.findall('task'): gnode = tnode.find('libgis') if gnode is not None and \ gnode.get('revision', '') != libgis_rev: ret.append(tnode.get('name')) return ret
def importR(): # R # unuseful since rpy2 will complain adequately. # try: # #@FIXME: in Windows, it launches R terminal # grass.find_program('R') # except: # sys.exit(_("R is not installed. Install it and re-run, or modify environment variables.")) # rpy2 global robjects global rinterface grass.message(_('Loading dependencies, please wait...')) try: import rpy2.robjects as robjects import rpy2.rinterface as rinterface # to speed up kriging? for plots. except ImportError: # ok for other OSes? grass.fatal(_("Python module 'Rpy2' not found. Please install it and re-run v.krige.")) # R packages check. Will create one error message after check of all packages. missingPackagesList = [] for each in ["rgeos", "gstat", "rgrass7", "maptools"]: if not robjects.r.require(each, quietly=True)[0]: missingPackagesList.append(each) if missingPackagesList: errorString = _("R package(s) ") + \ ", ".join(map(str, missingPackagesList)) + \ _(" missing. Install it/them and re-run v.krige.") grass.fatal(errorString)
def _export_vector_maps_as_gml(rows, tar, list_file, new_cwd, fs): for row in rows: name = row["name"] start = row["start_time"] end = row["end_time"] layer = row["layer"] if not layer: layer = 1 if not end: end = start string = "%s%s%s%s%s\n" % (name, fs, start, fs, end) # Write the filename, the start_time and the end_time list_file.write(string) # Export the vector map with v.out.ogr try: gscript.run_command("v.out.ogr", input=name, output=(name + ".xml"), layer=layer, format="GML") except CalledModuleError: shutil.rmtree(new_cwd) tar.close() gscript.fatal(_("Unable to export vector map <%s> as " "GML with v.out.ogr" % name)) tar.add(name + ".xml") tar.add(name + ".xsd")
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() try: from timeline.frame import TimelineFrame except ImportError as e: # TODO: why do we need this special check here, the reason of error # is wrong intallation or something, no need to report this to the # user in a nice way gscript.fatal(e.message) datasets = options['inputs'].strip().split(',') datasets = [data for data in datasets if data] view3d = flags['3'] app = wx.App() frame = TimelineFrame(None) frame.SetDatasets(datasets) frame.Show3D(view3d) frame.Show() app.MainLoop()
def ImportMap(self, map, column): """ Imports GRASS map as SpatialPointsDataFrame and adds x/y columns to attribute table. Checks for NULL values in the provided column and exits if they are present.""" #@NOTE: new way with R - as it doesn't alter original data Rpointmap = robjects.r.readVECT(map, type='point') # checks if x,y columns are present in dataframe. If they do are present, but with different names, # they'll be duplicated. if "x" not in robjects.r.names(Rpointmap): # extract coordinates with S4 method coordinatesPreDF = robjects.r['as.data.frame'](robjects.r.coordinates(Rpointmap)) coordinatesDF = robjects.r['data.frame'](x=coordinatesPreDF.rx('coords.x1')[0], y=coordinatesPreDF.rx('coords.x2')[0]) # match coordinates with data slot of SpatialPointsDataFrame - maptools function # match is done on row.names Rpointmap = robjects.r.spCbind(Rpointmap, coordinatesDF) # GRASS checks for null values in the chosen column. R can hardly handle column as a variable, # looks for a hardcoded string. cols = grass.vector_columns(map=map, layer=1) nulls = int(grass.parse_command('v.univar', map=map, column=column, type='point', parse=(grass.parse_key_val, {'sep': ': '} ) )['number of NULL attributes']) if nulls > 0: grass.fatal( _("%d NULL value(s) in the selected column - unable to perform kriging.") % nulls) return Rpointmap
def create_localities(loc): """ Read and parse the csv file of localities The csv file must have exactly 5 folumns: "Locality name" (a string), index (integer), code (3-4 letters), X coord, Y coord (floats) Create a python list, where each entry is a list of: ('Locality Name',Locality index,'Locality code, X coord, Y coord) Also Create a GRASS vector """ try: csv_file = open(loc,"rb") except IOError: grass.fatal("Cannot open localities file: "+loc) grass.message(" === Reading list of localities ===") locs=csv.reader(csv_file, delimiter=',') loc_list=[] for l in locs: # Add to the loc_list a tuple containing the code, X coord and Y coord loc_list.append([l[0],l[1],l[2],l[3],l[4]]) csv_file.close() # Make a GRASS vector loc_vector = os.path.splitext(loc)[0] grass.run_command('v.in.ascii', input=loc, output=loc_vector, fs=",", x=4, y=5, columns="loc_name varchar(32), id integer, code varchar(6), longitude double, latitude double", quiet=True, overwrite=True) return loc_list, loc_vector
def checkOutletAndFromto(self): '''Check number of outlets and change to negative values in outlets and subbasins table''' # check basin outlets grass.message('''Find outlets (if other than ID 1, check if the accumulation map has negative, ie. off-map flow)...''') # get fromto columns try: sboutin = readSubNxtID(self.subbasins) except ValueError: grass.fatal('Cant convert the subbasinID, nextID or inletID columns of %s to integers' %self.subbasins) outlets = sboutin[sboutin['subbasinID']==sboutin['nextID']] outlets['nextID'] = np.negative(outlets['nextID']) outlets['inletID']= 0 change = outlets.copy() # manual change using fromto if 'fromto' in self.options: # append to change array change=np.append(change,self.fromto) # update subbasins and outlets table update = lambda sbb,map,col,val: grun('v.db.update',map=map,column=col, where='subbasinID=%s' %sbb, value=val) # change for each row in change, in both vectors, both columns for s in change: for m in [self.subbasins,self.outlets]: for c in ['nextID','inletID']: update(s['subbasinID'],m,c,s[c]) # check outlets again for reporting sboutin = readSubNxtID(self.subbasins) outlets = sboutin[sboutin['subbasinID']==sboutin['nextID']] outlets = np.append(outlets,sboutin[sboutin['nextID']<=0]) grass.message('Subbasin(s) %s is(are) outlet(s)' %outlets['subbasinID']) return
def _fetchCapabilities(self, options, flags): """!Download capabilities from WCS server @return cap (instance of method _fetchDataFromServer) """ self._debug("_fetchCapabilities", "started") cap_url = options['url'].strip() if "?" in cap_url: cap_url += "&" else: cap_url += "?" cap_url += "SERVICE=WCS&REQUEST=GetCapabilities&VERSION=" + options['version'] if options['urlparams']: cap_url += "&" + options['urlparams'] gscript.message('Fetching capabilities file\n%s' % cap_url) try: cap = self._fetchDataFromServer(cap_url, options['username'], options['password']) print dir(cap) except (IOError, HTTPException), e: if urllib2.HTTPError == type(e) and e.code == 401: gscript.fatal(_("Authorization failed to <%s> when fetching capabilities") % options['url']) else: msg = _("Unable to fetch capabilities from <%s>: %s") % (options['url'], e) if hasattr(e, 'reason'): msg += _("\nReason: ") + str(e.reason) gscript.fatal(msg)
def _createVRT(self): '''! create VRT with help of gdalbuildvrt program VRT is a virtual GDAL dataset format @return path to VRT file ''' self._debug("_createVRT", "started") vrt_file = self._tempfile() command = ["gdalbuildvrt", '-te'] command += self.params['boundingbox'] command += [vrt_file, self.xml_file] command = [str(i) for i in command] gscript.verbose(' '.join(command)) self.process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) self.out, self.err = self.process.communicate() gscript.verbose(self.out) if self.err: gscript.verbose(self.err+"\n") if "does not exist" in self.err: gscript.warning('Coverage "%s" cannot be opened / does not exist.' % self.params['coverage']) gscript.fatal("Generation of VRT-File failed (gdalbuildvrt ERROR). Set verbose-flag for details.") self._debug("_createVRT", "finished") return vrt_file
def _initializeParameters(self, options, flags): ''' Initialize all given and needed parameters. Get region information and calculate boundingbox according to it ''' self._debug("_initializeParameters", "started") self._env = os.environ.copy() self._env['GRASS_MESSAGE_FORMAT'] = 'gui' g.gisenv(set="GRASS_MESSAGE_FORMAT=gui") for key in ['url', 'coverage','output','location']: self.params[key] = options[key].strip() if not self.params['output']: self.params['output'] = self.params['coverage'] if not gscript.overwrite(): result = gscript.find_file(name = self.params['output'], element = 'cell') if result['file']: gscript.fatal("Raster map <%s> does already exist. Choose other output name or toggle flag --o." % self.params['output']) for key in ['password', 'username', 'version','region']: self.params[key] = options[key] # check if authentication information is complete if (self.params['password'] and self.params['username'] == '') or \ (self.params['password'] == '' and self.params['username']): gscript.fatal(_("Please insert both %s and %s parameters or none of them." % ('password', 'username'))) # configure region extent (specified name or current region) self.params['region'] = self._getRegionParams(options['region']) self.params['boundingbox'] = self._computeBbox(self.params['region']) self._debug("_initializeParameters", "finished")
def _getRegionParams(self,opt_region): """!Get region parameters from region specified or active default region @return region_params as a dictionary """ self._debug("_getRegionParameters", "started") if opt_region: reg_spl = opt_region.strip().split('@', 1) reg_mapset = '.' if len(reg_spl) > 1: reg_mapset = reg_spl[1] if not gscript.find_file(name = reg_spl[0], element = 'windows', mapset = reg_mapset)['name']: gscript.fatal(_("Region <%s> not found") % opt_region) if opt_region: s = gscript.read_command('g.region', quiet = True, flags = 'ug', region = opt_region) region_params = gscript.parse_key_val(s, val_type = float) gscript.verbose("Using region parameters for region %s" %opt_region) else: region_params = gscript.region() gscript.verbose("Using current grass region") self._debug("_getRegionParameters", "finished") return region_params
def main(): options, flags = grass.parser() satellite = options['satellite'] output_basename = options['basename'] inputs = options['input'].split(',') num_of_bands = 6 if len(inputs) != num_of_bands: grass.fatal(_("The number of input raster maps (bands) should be %s") % num_of_bands) # this is here just for the compatibility with r.mapcalc expression # remove this if not really needed in new implementation bands = {} for i, band in enumerate(inputs): band_num = i + 1 if band_num == 6: band_num = 7 bands['band' + str(band_num)] = band print bands if satellite == 'landsat4_tm': calcN(output_basename, bands, 0, 4) elif satellite == 'landsat5_tm': calcN(output_basename, bands, 1, 5) elif satellite == 'landsat7_etm': calcN(output_basename, bands, 2, 7) elif satellite == 'modis': calcN(output_basename, bands, 3, 7) else: raise RuntimeError("Invalid satellite: " + satellite) grass.message(_("Tasseled Cap components calculated"))
def check_progs(): found_missing = False if not grass.find_program('v.mc.py'): found_missing = True grass.warning(_("'%s' required. Please install '%s' first \n using 'g.extension %s' or check \n PATH and GRASS_ADDON_PATH variables") % ('v.mc.py','v.mc.py','v.mc.py')) if found_missing: grass.fatal(_("An ERROR occurred running <v.ldm.py>"))
def main(): map = options['map'] layer = options['layer'] column = options['column'] mapset = grass.gisenv()['MAPSET'] if not grass.find_file(map, element = 'vector', mapset = mapset): grass.fatal(_("Vector map <%s> not found in current mapset") % map) f = grass.vector_layer_db(map, layer) table = f['table'] keycol = f['key'] database = f['database'] driver = f['driver'] if not table: grass.fatal(_("There is no table connected to the input vector map. Cannot rename any column")) cols = column.split(',') oldcol = cols[0] newcol = cols[1] if driver == "dbf": if len(newcol) > 10: grass.fatal(_("Column name <%s> too long. The DBF driver supports column names not longer than 10 characters") % newcol) if oldcol == keycol: grass.fatal(_("Cannot rename column <%s> as it is needed to keep table <%s> connected to the input vector map") % (oldcol, table)) # describe old col oldcoltype = None for f in grass.db_describe(table)['cols']: if f[0] != oldcol: continue oldcoltype = f[1] oldcollength = f[2] # old col there? if not oldcoltype: grass.fatal(_("Column <%s> not found in table <%s>") % (oldcol, table)) # some tricks if driver in ['sqlite', 'dbf']: if oldcoltype.upper() == "CHARACTER": colspec = "%s varchar(%s)" % (newcol, oldcollength) else: colspec = "%s %s" % (newcol, oldcoltype) grass.run_command('v.db.addcolumn', map = map, layer = layer, column = colspec) sql = "UPDATE %s SET %s=%s" % (table, newcol, oldcol) grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = sql) grass.run_command('v.db.dropcolumn', map = map, layer = layer, column = oldcol) else: sql = "ALTER TABLE %s RENAME %s TO %s" % (table, oldcol, newcol) grass.write_command('db.execute', input = '-', database = database, driver = driver, stdin = sql) # write cmd history: grass.vector_history(map)
def __init__(self, parent, title, vectmap, modeChoices, id = wx.ID_ANY, layer = 1): wx.Frame.__init__(self, parent, id, title) self.SetIcon(wx.Icon(os.path.join(globalvar.ICONDIR, 'grass_sql.ico'), wx.BITMAP_TYPE_ICO)) self.parent = parent # variables self.vectmap = vectmap # fullname if not "@" in self.vectmap: self.vectmap = grass.find_file(self.vectmap, element = 'vector')['fullname'] if not self.vectmap: grass.fatal(_("Vector map <%s> not found") % vectmap) self.mapname, self.mapset = self.vectmap.split("@", 1) # db info self.layer = layer self.dbInfo = VectorDBInfo(self.vectmap) self.tablename = self.dbInfo.GetTable(self.layer) self.driver, self.database = self.dbInfo.GetDbSettings(self.layer) self.colvalues = [] # array with unique values in selected column self.panel = wx.Panel(parent = self, id = wx.ID_ANY) # statusbar self.statusbar = self.CreateStatusBar(number=1) self._doLayout(modeChoices)
def main(): name = options["input"] type_ = options["type"] shellstyle = flags['g'] system = flags['d'] history = flags['h'] # Make sure the temporal database exists tgis.init() dbif, connected = tgis.init_dbif(None) rows = tgis.get_tgis_metadata(dbif) if system and not shellstyle: # 0123456789012345678901234567890 print(" +------------------- Temporal DBMI backend information ----------------------+") print(" | DBMI Python interface:...... " + str(dbif.get_dbmi().__name__)) print(" | Temporal database string:... " + str( tgis.get_tgis_database_string())) print(" | SQL template path:.......... " + str( tgis.get_sql_template_path())) if rows: for row in rows: print(" | %s .......... %s"%(row[0], row[1])) print(" +----------------------------------------------------------------------------+") return elif system: print("dbmi_python_interface=\'" + str(dbif.get_dbmi().__name__) + "\'") print("dbmi_string=\'" + str(tgis.get_tgis_database_string()) + "\'") print("sql_template_path=\'" + str(tgis.get_sql_template_path()) + "\'") if rows: for row in rows: print("%s=\'%s\'"%(row[0], row[1])) return if not system and not name: grass.fatal(_("Please specify %s=") % ("name")) if name.find("@") >= 0: id_ = name else: id_ = name + "@" + grass.gisenv()["MAPSET"] dataset = tgis.dataset_factory(type_, id_) if dataset.is_in_db(dbif) == False: grass.fatal(_("Dataset <%s> not found in temporal database") % (id_)) dataset.select(dbif) if history == True and type in ["strds", "stvds", "str3ds"]: dataset.print_history() return if shellstyle == True: dataset.print_shell_info() else: dataset.print_info()
def import_file(filename, archive, output, region): """Extracts one binary file from its archive and import it.""" # open the archive with ZipFile(archive, 'r') as a: # create temporary file and directory tempdir = grass.tempdir() tempfile = os.path.join(tempdir, filename) # try to inflate and import the layer try: grass.message("Inflating '%s' ..." % filename) a.extract(filename, tempdir) grass.message("Importing '%s' as <%s> ..." % (filename, output)) grass.run_command('r.in.bin', flags='s', overwrite=True, input=tempfile, output=output, bytes=2, anull=-9999, **region) # if file is not present in the archive except KeyError: grass.fatal("Could not find '%s' in '%s'" % (filename, archive)) # make sure temporary files are cleaned finally: grass.try_remove(tempfile) grass.try_rmdir(tempdir)
def __del__(self): # removes temporary mask, used for import transparent or warped temp_map if self.cleanup_mask: # clear temporary mask, which was set by module if grass.run_command("r.mask", quiet=True, flags="r") != 0: grass.fatal(_("%s failed") % "r.mask") # restore original mask, if exists if grass.find_file(self.opt_output + self.original_mask_suffix, element="cell", mapset=".")["name"]: if ( grass.run_command("g.copy", quiet=True, rast=self.opt_output + self.original_mask_suffix + ",MASK") != 0 ): grass.fatal(_("%s failed") % "g.copy") # remove temporary created rasters if self.cleanup_layers: maps = [] for suffix in (".red", ".green", ".blue", ".alpha", self.original_mask_suffix): rast = self.opt_output + suffix if grass.find_file(rast, element="cell", mapset=".")["file"]: maps.append(rast) if maps: grass.run_command("g.remove", quiet=True, flags="fb", type="rast", pattern=",".join(maps)) # delete environmental variable which overrides region if "GRASS_REGION" in os.environ.keys(): os.environ.pop("GRASS_REGION")
def check_map_name(name, mapset, element_type): if gscript.find_file(name, element=element_type, mapset=mapset)["file"]: gscript.fatal( _("Raster map <%s> already exists. " "Change the base name or allow overwrite.") % name)
def main(): grass.set_raise_on_error(False) options, flags = grass.parser() # import wx only after running parser # to avoid issues with complex imports when only interface is needed import wx from grass.script.setup import set_gui_path set_gui_path() from core.render import Map from mapdisp.frame import MapFrame from mapdisp.main import DMonGrassInterface from core.settings import UserSettings from vdigit.main import haveVDigit, errorMsg from grass.exceptions import CalledModuleError # define classes which needs imports as local # for longer definitions, a separate file would be a better option class VDigitMapFrame(MapFrame): def __init__(self, vectorMap): MapFrame.__init__( self, parent=None, Map=Map(), giface=DMonGrassInterface(None), title=_("GRASS GIS Vector Digitizer"), size=(850, 600)) # this giface issue not solved yet, we must set mapframe aferwards self._giface._mapframe = self # load vector map mapLayer = self.GetMap().AddLayer( ltype='vector', name=vectorMap, command=['d.vect', 'map=%s' % vectorMap], active=True, hidden=False, opacity=1.0, render=True) # switch toolbar self.AddToolbar('vdigit', fixed=True) # start editing self.toolbars['vdigit'].StartEditing(mapLayer) if not haveVDigit: grass.fatal(_("Vector digitizer not available. %s") % errorMsg) if not grass.find_file(name=options['map'], element='vector', mapset=grass.gisenv()['MAPSET'])['fullname']: if not flags['c']: grass.fatal(_("Vector map <%s> not found in current mapset. " "New vector map can be created by providing '-c' flag.") % options['map']) else: grass.verbose(_("New vector map <%s> created") % options['map']) try: grass.run_command( 'v.edit', map=options['map'], tool='create', quiet=True) except CalledModuleError: grass.fatal( _("Unable to create new vector map <%s>") % options['map']) # allow immediate rendering driver = UserSettings.Get(group='display', key='driver', subkey='type') if driver == 'png': os.environ['GRASS_RENDER_IMMEDIATE'] = 'png' else: os.environ['GRASS_RENDER_IMMEDIATE'] = 'cairo' app = wx.App() frame = VDigitMapFrame(options['map']) frame.Show() app.MainLoop()
def ImportMapIntoGRASS(self, raster): """!Import raster into GRASS. """ # importing temp_map into GRASS try: # do not use -o flag ! grass.run_command('r.in.gdal', flags='o', quiet=True, overwrite=True, input=raster, output=self.opt_output) except CalledModuleError: grass.fatal(_('%s failed') % 'r.in.gdal') # information for destructor to cleanup temp_layers, created # with r.in.gdal # setting region for full extend of imported raster if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file']: region_map = self.opt_output + '.red' else: region_map = self.opt_output os.environ['GRASS_REGION'] = grass.region_env(rast=region_map) # mask created from alpha layer, which describes real extend # of warped layer (may not be a rectangle), also mask contains # transparent parts of raster if grass.find_file(self.opt_output + '.alpha', element='cell', mapset='.')['name']: # saving current mask (if exists) into temp raster if grass.find_file('MASK', element='cell', mapset='.')['name']: try: mask_copy = self.opt_output + self.original_mask_suffix grass.run_command('g.copy', quiet=True, raster='MASK,' + mask_copy) except CalledModuleError: grass.fatal(_('%s failed') % 'g.copy') # info for destructor self.cleanup_mask = True try: grass.run_command('r.mask', quiet=True, overwrite=True, maskcats="0", flags='i', raster=self.opt_output + '.alpha') except CalledModuleError: grass.fatal(_('%s failed') % 'r.mask') if not self.cleanup_bands: # use the MASK to set NULL vlues for suffix in ('.red', '.green', '.blue'): rast = self.opt_output + suffix if grass.find_file(rast, element='cell', mapset='.')['file']: grass.run_command('g.rename', rast='%s,%s' % (rast, rast + '_null'), quiet=True) grass.run_command('r.mapcalc', expression='%s = %s' % (rast, rast + '_null'), quiet=True) grass.run_command('g.remove', type='raster', name='%s' % (rast + '_null'), flags='f', quiet=True) # TODO one band + alpha band? if grass.find_file(self.opt_output + '.red', element='cell', mapset='.')['file'] and self.cleanup_bands: try: grass.run_command('r.composite', quiet=True, overwrite=True, red=self.opt_output + '.red', green=self.opt_output + '.green', blue=self.opt_output + '.blue', output=self.opt_output) except CalledModuleError: grass.fatal(_('%s failed') % 'r.composite')
def main(options, flags): gisbase = os.getenv("GISBASE") if not gisbase: gs.fatal(_("$GISBASE not defined")) return 0 # Reference / sample area or points ref_rast = options["ref_rast"] ref_vect = options["ref_vect"] if ref_rast: reftype = gs.raster_info(ref_rast) if reftype["datatype"] != "CELL": gs.fatal(_("The ref_rast map must have type CELL (integer)")) if (reftype["min"] != 0 and reftype["min"] != 1) or reftype["max"] != 1: gs.fatal( _( "The ref_rast map must be a binary raster," " i.e. it should contain only values 0 and 1 or 1 only" " (now the minimum is {} and maximum is {})".format( reftype["min"], reftype["max"] ) ) ) # old environmental layers & variable names reference_layer = options["env"] reference_layer = reference_layer.split(",") raster_exists(reference_layer) variable_name = [z.split("@")[0] for z in reference_layer] variable_name = [x.lower() for x in variable_name] # new environmental variables projection_layers = options["env_proj"] if not projection_layers: to_be_projected = False projection_layers = reference_layer else: to_be_projected = True projection_layers = projection_layers.split(",") raster_exists(projection_layers) if ( len(projection_layers) != len(reference_layer) and len(projection_layers) != 0 ): gs.fatal( _( "The number of reference and predictor variables" " should be the same. You provided {} reference and {}" " projection variables".format( len(reference_layer), len(projection_layers) ) ) ) # output layers opl = options["output"] opc = opl + "_MES" ipi = [opl + "_" + i for i in variable_name] # flags flm = flags["m"] flk = flags["k"] fln = flags["n"] fli = flags["i"] flc = flags["c"] # digits / precision digits = int(options["digits"]) digits2 = pow(10, digits) # get current region settings, to compare to new ones later region_1 = gs.parse_command("g.region", flags="g") # Text for history in metadata opt2 = dict((k, v) for k, v in options.items() if v) hist = " ".join("{!s}={!r}".format(k, v) for (k, v) in opt2.items()) hist = "r.mess {}".format(hist) unused, tmphist = tempfile.mkstemp() with open(tmphist, "w") as text_file: text_file.write(hist) # Create reference layer if not defined if not ref_rast and not ref_vect: ref_rast = tmpname("tmp0") Module( "r.mapcalc", "{0} = if(isnull({1}),null(),1)".format(ref_rast, reference_layer[0]), quiet=True, ) # Create the recode table - Reference distribution is raster citiam = gs.find_file(name="MASK", element="cell", mapset=gs.gisenv()["MAPSET"]) if citiam["fullname"]: rname = tmpname("tmp3") Module("r.mapcalc", expression="{} = MASK".format(rname), quiet=True) if ref_rast: vtl = ref_rast # Create temporary layer based on reference layer tmpf0 = tmpname("tmp2") Module( "r.mapcalc", expression="{0} = int({1} * 1)".format(tmpf0, vtl), quiet=True ) Module("r.null", map=tmpf0, setnull=0, quiet=True) if citiam["fullname"]: Module("r.mask", flags="r", quiet=True) for i in range(len(reference_layer)): # Create mask based on combined MASK/reference layer Module("r.mask", raster=tmpf0, quiet=True) # Calculate the frequency distribution tmpf1 = tmpname("tmp4") Module( "r.mapcalc", expression="{0} = int({1} * {2})".format( tmpf1, digits2, reference_layer[i] ), quiet=True, ) stats_out = Module( "r.stats", flags="cn", input=tmpf1, sort="asc", separator=";", stdout_=PIPE, ).outputs.stdout stval = {} stats_outlines = stats_out.replace("\r", "").split("\n") stats_outlines = [_f for _f in stats_outlines if _f] for z in stats_outlines: [val, count] = z.split(";") stval[float(val)] = float(count) sstval = sorted(stval.items(), key=operator.itemgetter(0)) sstval = np.matrix(sstval) a = np.cumsum(np.array(sstval), axis=0) b = np.sum(np.array(sstval), axis=0) c = a[:, 1] / b[1] * 100 # Remove tmp mask and set region to env_proj if needed Module("r.mask", quiet=True, flags="r") if to_be_projected: gs.use_temp_region() Module("g.region", quiet=True, raster=projection_layers[0]) # get new region settings, to compare to original ones later region_2 = gs.parse_command("g.region", flags="g") # Get min and max values for recode table (based on full map) tmpf2 = tmpname("tmp5") Module( "r.mapcalc", expression="{0} = int({1} * {2})".format( tmpf2, digits2, projection_layers[i] ), quiet=True, ) d = gs.parse_command("r.univar", flags="g", map=tmpf2, quiet=True) # Create recode rules Dmin = int(d["min"]) Dmax = int(d["max"]) envmin = np.min(np.array(sstval), axis=0)[0] envmax = np.max(np.array(sstval), axis=0)[0] if Dmin < envmin: e1 = Dmin - 1 else: e1 = envmin - 1 if Dmax > envmax: e2 = Dmax + 1 else: e2 = envmax + 1 a1 = np.hstack([(e1), np.array(sstval.T[0])[0, :]]) a2 = np.hstack([np.array(sstval.T[0])[0, :] - 1, (e2)]) b1 = np.hstack([(0), c]) fd2, tmprule = tempfile.mkstemp(suffix=variable_name[i]) with open(tmprule, "w") as text_file: for k in np.arange(0, len(b1.T)): text_file.write( "%s:%s:%s\n" % (str(int(a1[k])), str(int(a2[k])), str(b1[k])) ) # Create the recode layer and calculate the IES compute_ies(tmprule, ipi[i], tmpf2, envmin, envmax) Module( "r.support", map=ipi[i], title="IES {}".format(reference_layer[i]), units="0-100 (relative score)", description="Environmental similarity {}".format(reference_layer[i]), loadhistory=tmphist, ) # Clean up os.close(fd2) os.remove(tmprule) # Change region back to original gs.del_temp_region() # Create the recode table - Reference distribution is vector else: vtl = ref_vect # Copy point layer and add columns for variables tmpf0 = tmpname("tmp7") Module( "v.extract", quiet=True, flags="t", input=vtl, type="point", output=tmpf0 ) Module("v.db.addtable", quiet=True, map=tmpf0) # TODO: see if there is a more efficient way to handle the mask if citiam["fullname"]: Module("r.mask", quiet=True, flags="r") # Upload raster values and get value in python as frequency table sql1 = "SELECT cat FROM {}".format(str(tmpf0)) cn = len(np.hstack(db.db_select(sql=sql1))) for m in range(len(reference_layer)): # Set mask back (this means that points outside the mask will # be ignored in the computation of the frequency distribution # of the reference variabele env(m)) if citiam["fullname"]: Module("g.copy", raster=[rname, "MASK"], quiet=True) # Compute frequency distribution of variable(m) mid = str(m) laytype = gs.raster_info(reference_layer[m])["datatype"] if laytype == "CELL": columns = "envvar_{} integer".format(str(mid)) else: columns = "envvar_{} double precision".format(str(mid)) Module("v.db.addcolumn", map=tmpf0, columns=columns, quiet=True) sql2 = "UPDATE {} SET envvar_{} = NULL".format(str(tmpf0), str(mid)) Module("db.execute", sql=sql2, quiet=True) coln = "envvar_{}".format(str(mid)) Module( "v.what.rast", quiet=True, map=tmpf0, layer=1, raster=reference_layer[m], column=coln, ) sql3 = ( "SELECT {0}, count({0}) from {1} WHERE {0} IS NOT NULL " "GROUP BY {0} ORDER BY {0}" ).format(coln, tmpf0) volval = np.vstack(db.db_select(sql=sql3)) volval = volval.astype(np.float, copy=False) a = np.cumsum(volval[:, 1], axis=0) b = np.sum(volval[:, 1], axis=0) c = a / b * 100 # Check for point without values if b < cn: gs.info( _( "Please note that there were {} points without " "value. This is probably because they are outside " "the computational region or mask".format((cn - b)) ) ) # Set region to env_proj layers (if different from env) and remove # mask (if set above) if citiam["fullname"]: Module("r.mask", quiet=True, flags="r") if to_be_projected: gs.use_temp_region() Module("g.region", quiet=True, raster=projection_layers[0]) region_2 = gs.parse_command("g.region", flags="g") # Multiply env_proj layer with dignum tmpf2 = tmpname("tmp8") Module( "r.mapcalc", expression="{0} = int({1} * {2})".format( tmpf2, digits2, projection_layers[m] ), quiet=True, ) # Calculate min and max values of sample points and raster layer envmin = int(min(volval[:, 0]) * digits2) envmax = int(max(volval[:, 0]) * digits2) Drange = gs.read_command("r.info", flags="r", map=tmpf2) Drange = str.splitlines(Drange) Drange = np.hstack([i.split("=") for i in Drange]) Dmin = int(Drange[1]) Dmax = int(Drange[3]) if Dmin < envmin: e1 = Dmin - 1 else: e1 = envmin - 1 if Dmax > envmax: e2 = Dmax + 1 else: e2 = envmax + 1 a0 = volval[:, 0] * digits2 a0 = a0.astype(np.int, copy=False) a1 = np.hstack([(e1), a0]) a2 = np.hstack([a0 - 1, (e2)]) b1 = np.hstack([(0), c]) fd3, tmprule = tempfile.mkstemp(suffix=variable_name[m]) with open(tmprule, "w") as text_file: for k in np.arange(0, len(b1)): rtmp = "{}:{}:{}\n".format( str(int(a1[k])), str(int(a2[k])), str(b1[k]) ) text_file.write(rtmp) # Create the recode layer and calculate the IES compute_ies(tmprule, ipi[m], tmpf2, envmin, envmax) Module( "r.support", map=ipi[m], title="IES {}".format(reference_layer[m]), units="0-100 (relative score)", description="Environmental similarity {}".format(reference_layer[m]), loadhistory=tmphist, ) # Clean up os.close(fd3) os.remove(tmprule) # Change region back to original gs.del_temp_region() # Calculate MESS statistics # Set region to env_proj layers (if different from env) # Note: this changes the region, to ensure the newly created layers # are actually visible to the user. This goes against normal practise # There will be a warning. if to_be_projected: Module("g.region", quiet=True, raster=projection_layers[0]) # MES Module("r.series", quiet=True, output=opc, input=ipi, method="minimum") gs.write_command("r.colors", map=opc, rules="-", stdin=COLORS_MES, quiet=True) # Write layer metadata Module( "r.support", map=opc, title="Areas with novel conditions", units="0-100 (relative score)", description="The multivariate environmental similarity" "(MES)", loadhistory=tmphist, ) # Area with negative MES if fln: mod1 = "{}_novel".format(opl) Module("r.mapcalc", "{} = int(if( {} < 0, 1, 0))".format(mod1, opc), quiet=True) # Write category labels Module("r.category", map=mod1, rules="-", stdin=RECL_MESNEG, quiet=True) # Write layer metadata Module( "r.support", map=mod1, title="Areas with novel conditions", units="-", source1="Based on {}".format(opc), description="1 = novel conditions, 0 = within range", loadhistory=tmphist, ) # Most dissimilar variable (MoD) if flm: tmpf4 = tmpname("tmp9") mod2 = "{}_MoD".format(opl) Module("r.series", quiet=True, output=tmpf4, input=ipi, method="min_raster") Module("r.mapcalc", "{} = int({})".format(mod2, tmpf4), quiet=True) fd4, tmpcat = tempfile.mkstemp() with open(tmpcat, "w") as text_file: for cats in range(len(ipi)): text_file.write("{}:{}\n".format(str(cats), reference_layer[cats])) Module("r.category", quiet=True, map=mod2, rules=tmpcat, separator=":") os.close(fd4) os.remove(tmpcat) # Write layer metadata Module( "r.support", map=mod2, title="Most dissimilar variable (MoD)", units="-", source1="Based on {}".format(opc), description="Name of most dissimilar variable", loadhistory=tmphist, ) # sum(IES), where IES < 0 if flk: mod3 = "{}_SumNeg".format(opl) c0 = -0.01 / digits2 Module( "r.series", quiet=True, input=ipi, method="sum", range=("-inf", c0), output=mod3, ) gs.write_command("r.colors", map=mod3, rules="-", stdin=COLORS_MES, quiet=True) # Write layer metadata Module( "r.support", map=mod3, title="Sum of negative IES values", units="-", source1="Based on {}".format(opc), description="Sum of negative IES values", loadhistory=tmphist, ) # Number of layers with negative values if flc: tmpf5 = tmpname("tmp10") mod4 = "{}_CountNeg".format(opl) MinMes = gs.read_command("r.info", quiet=True, flags="r", map=opc) MinMes = str.splitlines(MinMes) MinMes = float(np.hstack([i.split("=") for i in MinMes])[1]) c0 = -0.0001 / digits2 Module( "r.series", quiet=True, input=ipi, output=tmpf5, method="count", range=(MinMes, c0), ) gs.mapcalc("$mod4 = int($tmpf5)", mod4=mod4, tmpf5=tmpf5, quiet=True) # Write layer metadata Module( "r.support", map=mod4, title="Number of layers with negative values", units="-", source1="Based on {}".format(opc), description="Number of layers with negative values", loadhistory=tmphist, ) # Remove IES layers if fli: Module("g.remove", quiet=True, flags="f", type="raster", name=ipi) # Clean up tmp file # os.remove(tmphist) gs.message(_("Finished ...\n")) if region_1 != region_2: gs.message( _( "\nPlease note that the region has been changes to match" " the set of projection (env_proj) variables.\n" ) )
def main(): # Get the options file = options["file"] input = options["input"] maps = options["maps"] type = options["type"] # Make sure the temporal database exists tgis.init() if maps and file: grass.fatal(_( "%s= and %s= are mutually exclusive") % ("input", "file")) if not maps and not file: grass.fatal(_("%s= or %s= must be specified") % ("input", "file")) mapset = grass.gisenv()["MAPSET"] dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() # In case a space time dataset is specified if input: sp = tgis.open_old_stds(input, type, dbif) maplist = [] dummy = tgis.RasterDataset(None) # Map names as comma separated string if maps is not None and maps != "": if maps.find(",") == -1: maplist = [maps, ] else: maplist = maps.split(",") # Build the maplist for count in range(len(maplist)): mapname = maplist[count] mapid = dummy.build_id(mapname, mapset) maplist[count] = mapid # Read the map list from file if file: fd = open(file, "r") line = True while True: line = fd.readline() if not line: break mapname = line.strip() mapid = dummy.build_id(mapname, mapset) maplist.append(mapid) num_maps = len(maplist) update_dict = {} count = 0 statement = "" # Unregister already registered maps grass.message(_("Unregister maps")) for mapid in maplist: if count%10 == 0: grass.percent(count, num_maps, 1) map = tgis.dataset_factory(type, mapid) # Unregister map if in database if map.is_in_db(dbif) == True: # Unregister from a single dataset if input: # Collect SQL statements statement += sp.unregister_map( map=map, dbif=dbif, execute=False) # Unregister from temporal database else: # We need to update all datasets after the removement of maps map.metadata.select(dbif) datasets = map.get_registered_stds(dbif) # Store all unique dataset ids in a dictionary if datasets: for dataset in datasets: update_dict[dataset] = dataset # Collect SQL statements statement += map.delete(dbif=dbif, update=False, execute=False) else: grass.warning(_("Unable to find %s map <%s> in temporal database" % (map.get_type(), map.get_id()))) count += 1 # Execute the collected SQL statenents if statement: dbif.execute_transaction(statement) grass.percent(num_maps, num_maps, 1) # Update space time datasets grass.message(_("Unregister maps from space time dataset(s)")) if input: sp.update_from_registered_maps(dbif) sp.update_command_string(dbif=dbif) elif len(update_dict) > 0: count = 0 for key in update_dict.keys(): id = update_dict[key] sp = tgis.open_old_stds(id, type, dbif) sp.update_from_registered_maps(dbif) grass.percent(count, len(update_dict), 1) count += 1 dbif.close()
def main(): repeat = int(options.pop("repeat")) nprocs = int(options.pop("nprocs")) subregions = options["subregions"] tosplit = flags["d"] # filter unused optional params for key in list(options.keys()): if options[key] == "": options.pop(key) if tosplit and "output_series" in options: gscript.fatal( _("Parallelization on subregion level is not supported together with <output_series> option" )) if (not gscript.overwrite() and gscript.list_grouped( "raster", pattern=options["output"] + "_run1")[gscript.gisenv()["MAPSET"]]): gscript.fatal( _("Raster map <{r}> already exists." " To overwrite, use the --overwrite flag").format( r=options["output"] + "_run1")) global TMP_RASTERS cats = [] if tosplit: gscript.message(_("Splitting subregions")) cats = (gscript.read_command("r.stats", flags="n", input=subregions).strip().splitlines()) if len(cats) < 2: gscript.fatal( _("Not enough subregions to split computation. Do not use -d flag." )) mapcalcs = [] for cat in cats: new = PREFIX + cat TMP_RASTERS.append(new) mapcalcs.append("{new} = if({sub} == {cat}, {sub}, null())".format( sub=subregions, cat=cat, new=new)) pool = Pool(nprocs) p = pool.map_async(split_subregions, mapcalcs) try: p.wait() except (KeyboardInterrupt, CalledModuleError): return options_list = [] for i in range(repeat): if cats: for cat in cats: op = options.copy() op["random_seed"] = i + 1 if "output_series" in op: op["output_series"] += "_run" + str(i + 1) + "_" + cat TMP_RASTERS.append(op["output_series"]) op["output"] += "_run" + str(i + 1) + "_" + cat op["subregions"] = PREFIX + cat options_list.append((repeat, i + 1, cat, op)) TMP_RASTERS.append(op["output"]) else: op = options.copy() op["random_seed"] = i + 1 if "output_series" in op: op["output_series"] += "_run" + str(i + 1) op["output"] += "_run" + str(i + 1) options_list.append((repeat, i + 1, None, op)) pool = Pool(nprocs) p = pool.map_async(futures_process, options_list) try: p.wait() except (KeyboardInterrupt, CalledModuleError): return if cats: gscript.message(_("Patching subregions")) for i in range(repeat): patch_input = [ options["output"] + "_run" + str(i + 1) + "_" + cat for cat in cats ] gscript.run_command( "r.patch", input=patch_input, output=options["output"] + "_run" + str(i + 1), ) return 0
def main(): map = options['map'] layer = options['layer'] column = options['column'] otable = options['other_table'] ocolumn = options['other_column'] if options['subset_columns']: scolumns = options['subset_columns'].split(',') else: scolumns = None try: f = grass.vector_layer_db(map, layer) except CalledModuleError: sys.exit(1) maptable = f['table'] database = f['database'] driver = f['driver'] if driver == 'dbf': grass.fatal(_("JOIN is not supported for tables stored in DBF format")) if not maptable: grass.fatal( _("There is no table connected to this map. Unable to join any column." )) # check if column is in map table if column not in grass.vector_columns(map, layer): grass.fatal( _("Column <%s> not found in table <%s>") % (column, maptable)) # describe other table all_cols_ot = grass.db_describe(otable, driver=driver, database=database)['cols'] # check if ocolumn is on other table if ocolumn not in [ocol[0] for ocol in all_cols_ot]: grass.fatal( _("Column <%s> not found in table <%s>") % (ocolumn, otable)) # determine columns subset from other table if not scolumns: # select all columns from other table cols_to_add = all_cols_ot else: cols_to_add = [] # check if scolumns exists in the other table for scol in scolumns: found = False for col_ot in all_cols_ot: if scol == col_ot[0]: found = True cols_to_add.append(col_ot) break if not found: grass.warning( _("Column <%s> not found in table <%s>") % (scol, otable)) all_cols_tt = grass.vector_columns(map, int(layer)).keys() select = "SELECT $colname FROM $otable WHERE $otable.$ocolumn=$table.$column" template = string.Template("UPDATE $table SET $colname=(%s);" % select) for col in cols_to_add: # skip the vector column which is used for join colname = col[0] if colname == column: continue use_len = False if len(col) > 2: use_len = True # Sqlite 3 does not support the precision number any more if driver == "sqlite": use_len = False # MySQL - expect format DOUBLE PRECISION(M,D), see #2792 elif driver == "mysql" and col[1] == 'DOUBLE PRECISION': use_len = False if use_len: coltype = "%s(%s)" % (col[1], col[2]) else: coltype = "%s" % col[1] colspec = "%s %s" % (colname, coltype) # add only the new column to the table if colname not in all_cols_tt: try: grass.run_command('v.db.addcolumn', map=map, columns=colspec, layer=layer) except CalledModuleError: grass.fatal(_("Error creating column <%s>") % colname) stmt = template.substitute(table=maptable, column=column, otable=otable, ocolumn=ocolumn, colname=colname) grass.debug(stmt, 1) grass.verbose( _("Updating column <%s> of vector map <%s>...") % (colname, map)) try: grass.write_command('db.execute', stdin=stmt, input='-', database=database, driver=driver) except CalledModuleError: grass.fatal(_("Error filling column <%s>") % colname) # write cmd history grass.vector_history(map) return 0
def main(): settings = options['settings'] scene_names = options['scene_name'].split(',') output = options['output'] nprocs = int(options['nprocs']) clouds = int(options['clouds']) producttype = options['producttype'] start = options['start'] end = options['end'] use_scenenames = flags['s'] ind_folder = flags['f'] ### check if we have the i.sentinel.download + i.sentinel.import addons if not grass.find_program('i.sentinel.download', '--help'): grass.fatal( _("The 'i.sentinel.download' module was not found, install it first:" ) + "\n" + "g.extension i.sentinel") ### Test if all required data are there if not os.path.isfile(settings): grass.fatal(_("Settings file <%s> not found" % (settings))) ### set some common environmental variables, like: os.environ.update( dict(GRASS_COMPRESS_NULLS='1', GRASS_COMPRESSOR='ZSTD', GRASS_MESSAGE_FORMAT='plain')) ### test nprocs Settings if nprocs > mp.cpu_count(): grass.fatal("Using %d parallel processes but only %d CPUs available." % (nprocs, mp.cpu_count())) ### sentinelsat allows only three parallel downloads elif nprocs > 2: grass.message("Maximum number of parallel processes for Downloading" + " fixed to 2 due to sentinelsat API restrictions") nprocs = 2 if use_scenenames: scenenames = scene_names ### check if the filename is valid ### TODO: refine check, it's currently a very lazy check if len(scenenames[0]) < 10: grass.fatal( "No scene names indicated. Please provide scenenames in \ the format S2A_MSIL1C_20180822T155901_N0206_R097_T17SPV_20180822T212023.SAFE" ) else: ### get a list of scenenames to download i_sentinel_download_string = grass.parse_command( 'i.sentinel.download', settings=settings, producttype=producttype, start=start, end=end, clouds=clouds, flags='l') i_sentinel_keys = i_sentinel_download_string.keys() scenenames = [item.split(' ')[1] for item in i_sentinel_keys] ### parallelize download grass.message(_("Downloading Sentinel-2 data...")) ### adapt nprocs to number of scenes if len(scenenames) == 1: nprocs = 1 queue_download = ParallelModuleQueue(nprocs=nprocs) for idx, scenename in enumerate(scenenames): producttype, start_date, end_date, query_string = scenename_split( scenename) ### output into separate folders, easier to import in a parallel way: if ind_folder: outpath = os.path.join(output, 'dl_s2_%s' % str(idx + 1)) else: outpath = output i_sentinel_download = Module('i.sentinel.download', settings=settings, start=start_date, end=end_date, producttype=producttype, query=query_string, output=outpath, run_=False) queue_download.put(i_sentinel_download) queue_download.wait()
def checkPercentile(per, di): """Check if percentile option is set with the oblique directions""" if not per and di in ["NW-SE", "NE-SW", "SW-NE", "SE-NW"]: grass.fatal( "Percentile option has to be set with {dire} direction".format(dire=di) )
def main(): global tmp tmp = grass.tempfile() extend = flags['e'] shellstyle = flags['g'] table = options['table'] column = options['column'] database = options['database'] driver = options['driver'] where = options['where'] perc = options['percentile'] perc = [float(p) for p in perc.split(',')] desc_table = grass.db_describe(table, database=database, driver=driver) if not desc_table: grass.fatal(_("Unable to describe table <%s>") % table) found = False for cname, ctype, cwidth in desc_table['cols']: if cname == column: found = True if ctype not in ('INTEGER', 'DOUBLE PRECISION'): grass.fatal(_("Column <%s> is not numeric") % cname) if not found: grass.fatal(_("Column <%s> not found in table <%s>") % (column, table)) if not shellstyle: grass.verbose(_("Calculation for column <%s> of table <%s>...") % (column, table)) grass.message(_("Reading column values...")) sql = "SELECT %s FROM %s" % (column, table) if where: sql += " WHERE " + where if not database: database = None if not driver: driver = None tmpf = file(tmp, 'w') grass.run_command('db.select', flags = 'c', table = table, database = database, driver = driver, sql = sql, stdout = tmpf) tmpf.close() # check if result is empty tmpf = file(tmp) if tmpf.read(1) == '': grass.fatal(_("Table <%s> contains no data.") % table) tmpf.close() # calculate statistics if not shellstyle: grass.verbose(_("Calculating statistics...")) N = 0 sum = 0.0 sum2 = 0.0 sum3 = 0.0 minv = 1e300 maxv = -1e300 tmpf = file(tmp) for line in tmpf: if len(line.rstrip('\r\n')) == 0: continue x = float(line.rstrip('\r\n')) N += 1 sum += x sum2 += x * x sum3 += abs(x) maxv = max(maxv, x) minv = min(minv, x) tmpf.close() if N <= 0: grass.fatal(_("No non-null values found")) if not shellstyle: sys.stdout.write("Number of values: %d\n"% N) sys.stdout.write("Minimum: %.15g\n"% minv) sys.stdout.write("Maximum: %.15g\n"% maxv) sys.stdout.write("Range: %.15g\n"% (maxv - minv)) sys.stdout.write("Mean: %.15g\n"% (sum/N)) sys.stdout.write("Arithmetic mean of absolute values: %.15g\n"% (sum3/N)) sys.stdout.write("Variance: %.15g\n"% ((sum2 - sum*sum/N)/N)) sys.stdout.write("Standard deviation: %.15g\n"% (math.sqrt((sum2 - sum*sum/N)/N))) sys.stdout.write("Coefficient of variation: %.15g\n"% ((math.sqrt((sum2 - sum*sum/N)/N))/(math.sqrt(sum*sum)/N))) sys.stdout.write("Sum: %.15g\n"% sum) else: sys.stdout.write("n=%d\n"% N) sys.stdout.write("min=%.15g\n"% minv) sys.stdout.write("max=%.15g\n"% maxv) sys.stdout.write("range=%.15g\n"% (maxv - minv)) sys.stdout.write("mean=%.15g\n"% (sum/N)) sys.stdout.write("mean_abs=%.15g\n"% (sum3/N)) sys.stdout.write("variance=%.15g\n"% ((sum2 - sum*sum/N)/N)) sys.stdout.write("stddev=%.15g\n"% (math.sqrt((sum2 - sum*sum/N)/N))) sys.stdout.write("coeff_var=%.15g\n"% ((math.sqrt((sum2 - sum*sum/N)/N))/(math.sqrt(sum*sum)/N))) sys.stdout.write("sum=%.15g\n"% sum) if not extend: return # preparations: sortfile(tmp, tmp + ".sort") number = N odd = N % 2 eostr = ['even','odd'][odd] q25pos = round(N * 0.25) if q25pos == 0: q25pos = 1 q50apos = round(N * 0.50) if q50apos == 0: q50apos = 1 q50bpos = q50apos + (1 - odd) q75pos = round(N * 0.75) if q75pos == 0: q75pos = 1 ppos = {} pval = {} for i in range(len(perc)): ppos[i] = round(N * perc[i] / 100) if ppos[i] == 0: ppos[i] = 1 pval[i] = 0 inf = file(tmp + ".sort") l = 1 for line in inf: if l == q25pos: q25 = float(line.rstrip('\r\n')) if l == q50apos: q50a = float(line.rstrip('\r\n')) if l == q50bpos: q50b = float(line.rstrip('\r\n')) if l == q75pos: q75 = float(line.rstrip('\r\n')) for i in range(len(ppos)): if l == ppos[i]: pval[i] = float(line.rstrip('\r\n')) l += 1 q50 = (q50a + q50b) / 2 if not shellstyle: sys.stdout.write("1st Quartile: %.15g\n" % q25) sys.stdout.write("Median (%s N): %.15g\n" % (eostr, q50)) sys.stdout.write("3rd Quartile: %.15g\n" % q75) for i in range(len(perc)): if perc[i] == int(perc[i]): # integer if int(perc[i]) % 10 == 1 and int(perc[i]) != 11: sys.stdout.write("%dst Percentile: %.15g\n"% (int(perc[i]), pval[i])) elif int(perc[i]) % 10 == 2 and int(perc[i]) != 12: sys.stdout.write("%dnd Percentile: %.15g\n"% (int(perc[i]), pval[i])) elif int(perc[i]) % 10 == 3 and int(perc[i]) != 13: sys.stdout.write("%drd Percentile: %.15g\n"% (int(perc[i]), pval[i])) else: sys.stdout.write("%dth Percentile: %.15g\n"% (int(perc[i]), pval[i])) else: sys.stdout.write("%.15g Percentile: %.15g\n"% (perc[i], pval[i])) else: sys.stdout.write("first_quartile=%.15g\n"% q25) sys.stdout.write("median=%.15g\n"% q50) sys.stdout.write("third_quartile=%.15g\n"% q75) for i in range(len(perc)): percstr = "%.15g" % perc[i] percstr = percstr.replace('.','_') sys.stdout.write("percentile_%s=%.15g\n"% (percstr, pval[i]))
def main(): #lazy imports import grass.temporal as tgis # Get the options input = options["input"] output = options["output"] vector_output = options["vector_output"] strds = options["strds"] where = options["where"] columns = options["columns"] if where == "" or where == " " or where == "\n": where = None overwrite = grass.overwrite() # Check the number of sample strds and the number of columns strds_names = strds.split(",") column_names = columns.split(",") if len(strds_names) != len(column_names): grass.fatal( _("The number of columns must be equal to the number of space time raster datasets" )) # Make sure the temporal database exists tgis.init() # We need a database interface dbif = tgis.SQLDatabaseInterfaceConnection() dbif.connect() mapset = grass.gisenv()["MAPSET"] out_sp = tgis.check_new_stds(output, "stvds", dbif, overwrite) samples = [] first_strds = tgis.open_old_stds(strds_names[0], "strds", dbif) # Single space time raster dataset if len(strds_names) == 1: rows = first_strds.get_registered_maps( columns="name,mapset,start_time,end_time", order="start_time", dbif=dbif) if not rows: dbif.close() grass.fatal( _("Space time raster dataset <%s> is empty") % out_sp.get_id()) for row in rows: start = row["start_time"] end = row["end_time"] raster_maps = [ row["name"] + "@" + row["mapset"], ] s = Sample(start, end, raster_maps) samples.append(s) else: # Multiple space time raster datasets for name in strds_names[1:]: dataset = tgis.open_old_stds(name, "strds", dbif) if dataset.get_temporal_type() != first_strds.get_temporal_type(): grass.fatal(_("Temporal type of space time raster datasets must be equal\n" "<%(a)s> of type %(type_a)s do not match <%(b)s> of type %(type_b)s"%\ {"a":first_strds.get_id(), "type_a":first_strds.get_temporal_type(), "b":dataset.get_id(), "type_b":dataset.get_temporal_type()})) mapmatrizes = tgis.sample_stds_by_stds_topology( "strds", "strds", strds_names, strds_names[0], False, None, "equal", False, False) for i in range(len(mapmatrizes[0])): isvalid = True mapname_list = [] for mapmatrix in mapmatrizes: entry = mapmatrix[i] if entry["samples"]: sample = entry["samples"][0] name = sample.get_id() if name is None: isvalid = False break else: mapname_list.append(name) if isvalid: entry = mapmatrizes[0][i] map = entry["granule"] start, end = map.get_temporal_extent_as_tuple() s = Sample(start, end, mapname_list) samples.append(s) num_samples = len(samples) # Get the layer and database connections of the input vector vector_db = grass.vector.vector_db(input) # We copy the vector table and create the new layers if vector_db: # Use the first layer to copy the categories from layers = "1," else: layers = "" first = True for layer in range(num_samples): layer += 1 # Skip existing layer if vector_db and layer in vector_db and \ vector_db[layer]["layer"] == layer: continue if first: layers += "%i" % (layer) first = False else: layers += ",%i" % (layer) vectmap = vector_output # We create a new vector map using the categories of the original map try: grass.run_command("v.category", input=input, layer=layers, output=vectmap, option="transfer", overwrite=overwrite) except CalledModuleError: grass.fatal( _("Unable to create new layers for vector map <%s>") % (vectmap)) title = _("Observaion of space time raster dataset(s) <%s>") % (strds) description = _("Observation of space time raster dataset(s) <%s>" " with vector map <%s>") % (strds, input) # Create the output space time vector dataset out_sp = tgis.open_new_stds(output, "stvds", first_strds.get_temporal_type(), title, description, first_strds.get_semantic_type(), dbif, overwrite) dummy = out_sp.get_new_map_instance(None) # Sample the space time raster dataset with the vector # map at specific layer with v.what.rast count = 1 for sample in samples: raster_names = sample.raster_names if len(raster_names) != len(column_names): grass.fatal( _("The number of raster maps in a granule must " "be equal to the number of column names")) # Create the columns creation string columns_string = "" for name, column in zip(raster_names, column_names): # The column is by default double precision coltype = "DOUBLE PRECISION" # Get raster map type raster_map = tgis.RasterDataset(name) raster_map.load() if raster_map.metadata.get_datatype() == "CELL": coltype = "INT" tmp_string = "%s %s," % (column, coltype) columns_string += tmp_string # Remove last comma columns_string = columns_string[0:len(columns_string) - 1] # Try to add a column if vector_db and count in vector_db and vector_db[count]["table"]: try: grass.run_command("v.db.addcolumn", map=vectmap, layer=count, column=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal( _("Unable to add column %s to vector map <%s> " "with layer %i") % (columns_string, vectmap, count)) else: # Try to add a new table grass.message("Add table to layer %i" % (count)) try: grass.run_command("v.db.addtable", map=vectmap, layer=count, columns=columns_string, overwrite=overwrite) except CalledModuleError: dbif.close() grass.fatal( _("Unable to add table to vector map " "<%s> with layer %i") % (vectmap, count)) # Call v.what.rast for each raster map for name, column in zip(raster_names, column_names): try: grass.run_command("v.what.rast", map=vectmap, layer=count, raster=name, column=column, where=where) except CalledModuleError: dbif.close() grass.fatal(_("Unable to run v.what.rast for vector map <%s> " "with layer %i and raster map <%s>") % \ (vectmap, count, str(raster_names))) vect = out_sp.get_new_map_instance( dummy.build_id(vectmap, mapset, str(count))) vect.load() start = sample.start end = sample.end if out_sp.is_time_absolute(): vect.set_absolute_time(start, end) else: vect.set_relative_time(start, end, first_strds.get_relative_time_unit()) if vect.is_in_db(dbif): vect.update_all(dbif) else: vect.insert(dbif) out_sp.register_map(vect, dbif) count += 1 out_sp.update_from_registered_maps(dbif) dbif.close()
def main(): inmap = options["input"] outmap = options["output"] coor = options["coor"] coor = coor.replace(",", " ") global tmp, grass_version # setup temporary files tmp = grass.tempfile() # check for LatLong location if grass.locn_is_latlong(): grass.fatal("Module works only in locations with cartesian coordinate system") # check if input file exists if not grass.find_file(inmap, element="vector")["file"]: grass.fatal(_("<%s> does not exist.") % inmap) ## DO IT ## ## add categories to boundaries grass.run_command( "v.category", input_=inmap, option="add", type_="boundary", output="v_temp_bcats", quiet=True, stderr=None, ) ## export polygons to CSV + WKT tmp1 = tmp + ".csv" tmp2 = tmp + "2.csv" grass.run_command( "v.out.ogr", input_="v_temp_bcats", output=tmp1, format_="CSV", type_=("boundary"), lco="GEOMETRY=AS_WKT", quiet=True, stderr=None, ) ## convert lines to polygons f1 = open(tmp1, "r") f2 = open(tmp2, "w") for line in f1: f2.write( line.replace("LINESTRING", "POLYGON") .replace(" (", " ((") .replace(')"', '))"') ) f1.close() f2.close() with open(tmp2, "r") as f: print(f.read()) ## open CSV with OGR and get layer name f = ogr.Open(tmp2, 0) lyr = f.GetLayer(0) lyr_name = lyr.GetName() ## make spatial query with coordinates coords = "%s %s" % (coor, coor) tmp3 = tmp + "_v_temp_select.shp" cmd = "ogr2ogr " + " -spat " + coords + " " + tmp3 + " " + tmp2 + " " + lyr_name os.system(cmd) ## open SHP with OGR and get layer name f = ogr.Open(tmp3, 0) lyr = f.GetLayer(0) lyr_name = lyr.GetName() ## print selected objects to stdout or write into vector map if flags["p"]: cmd = "ogrinfo -al -fields=YES -geom=SUMMARY" + " " + tmp3 + " " + lyr_name os.system(cmd) else: grass.run_command( "v.in.ogr", input_=tmp3, layer=lyr_name, output=outmap, flags="c", quiet=True, stderr=None, )
def matchhist(original, target, matched): # pan/intensity histogram matching using numpy arrays grass.message(_("Histogram matching...")) # input images original = original.split("@")[0] target = target.split("@")[0] images = [original, target] # create a dictionary to hold arrays for each image arrays = {} for img in images: # calculate number of cells for each grey value for for each image stats_out = grass.pipe_command("r.stats", flags="cin", input=img, sep=":") stats = grass.decode(stats_out.communicate()[0]).split("\n")[:-1] stats_dict = dict(s.split(":", 1) for s in stats) total_cells = 0 # total non-null cells for j in stats_dict: stats_dict[j] = int(stats_dict[j]) if j != "*": total_cells += stats_dict[j] if total_cells < 1: grass.fatal(_("Input has no data. Check region settings.")) # Make a 2x256 structured array for each image with a # cumulative distribution function (CDF) for each grey value. # Grey value is the integer (i4) and cdf is float (f4). arrays[img] = np.zeros((256,), dtype=("i4,f4")) cum_cells = ( 0 # cumulative total of cells for sum of current and all lower grey values ) for n in range(0, 256): if str(n) in stats_dict: num_cells = stats_dict[str(n)] else: num_cells = 0 cum_cells += num_cells # cdf is the the number of cells at or below a given grey value # divided by the total number of cells cdf = float(cum_cells) / float(total_cells) # insert values into array arrays[img][n] = (n, cdf) # open file for reclass rules outfile = open(grass.tempfile(), "w") for i in arrays[original]: # for each grey value and corresponding cdf value in original, find the # cdf value in target that is closest to the target cdf value difference_list = [] for j in arrays[target]: # make a list of the difference between each original cdf value and # the target cdf value difference_list.append(abs(i[1] - j[1])) # get the smallest difference in the list min_difference = min(difference_list) for j in arrays[target]: # find the grey value in target that corresponds to the cdf # closest to the original cdf if j[1] <= i[1] + min_difference and j[1] >= i[1] - min_difference: # build a reclass rules file from the original grey value and # corresponding grey value from target out_line = "%d = %d\n" % (i[0], j[0]) outfile.write(out_line) break outfile.close() # create reclass of target from reclass rules file result = grass.core.find_file(matched, element="cell") if result["fullname"]: grass.run_command( "g.remove", flags="f", quiet=True, type="raster", name=matched ) grass.run_command("r.reclass", input=original, out=matched, rules=outfile.name) else: grass.run_command("r.reclass", input=original, out=matched, rules=outfile.name) # Cleanup # remove the rules file grass.try_remove(outfile.name) # return reclass of target with histogram that matches original return matched
def main(): # leggo variabili r_elevation = options['dem'].split('@')[0] mapname = options['dem'].replace("@", " ") mapname = mapname.split() mapname[0] = mapname[0].replace(".", "_") start = options['start'] start_ = start.split('@')[0] gfile = grass.find_file(start, element='vector') if not gfile['name']: grass.fatal(_("Vector map <%s> not found") % infile) #x = options['x'] #y = options['y'] #z = options['z'] ang = options['ang'] red = options['red'] m = options['m'] num = options['num'] n = options['n'] #if n == '': # n = 1 #else: # n = float(n) grass.message("Setting variables...") prefix = options['prefix'] rocks = prefix + '_propagation' v = prefix + '_vel' vMax = v + '_max' vMean = v + '_mean' e = prefix + '_en' eMax = e + '_max' eMean = e + '_mean' gregion = grass.region() PixelWidth = gregion['ewres'] if n == '': n = 1 d_buff = (float(num) * PixelWidth) / 2 else: n = float(n) d_buff = n #d_buff = (n * PixelWidth)/2 grass.message("Defining starting points...") if int(num) == 1: grass.run_command('g.copy', vector=start + ',start_points_', quiet=True) else: grass.run_command('v.buffer', input=start, type='point', output='start_buffer_', distance=d_buff, quiet=True) grass.run_command('v.random', input='start_buffer_', npoints=num, output='start_random_', flags='a', quiet=True) grass.run_command('v.patch', input=start + ',start_random_', output='start_points_', quiet=True) #v.buffer input=punto type=point output=punti_buffer distance=$cellsize #v.random -a output=random n=$numero input=punti_buffer #v.patch input=punto,random output=patch1 #creo raster (che sara' il DEM di input) con valore 1 grass.mapcalc('uno=$dem*0+1', dem=r_elevation, quiet=True) what = grass.read_command( 'r.what', map=r_elevation, points='start_points_', null_value= "-9999", # TODO: a better test for points outside the current region is needed quiet=True) quota = what.split('\n') #array per la somma dei massi tot = garray.array() tot.read(r_elevation) tot[...] = (tot * 0.0).astype(float) somma = garray.array() #array per le velocita velocity = garray.array() velMax = garray.array() velMean = garray.array() #array per energia energy = garray.array() enMax = garray.array() enMean = garray.array() grass.message("Waiting...") for i in xrange(len(quota) - 1): grass.message("Shoot number: " + str(i + 1)) z = float(quota[i].split('||')[1]) point = quota[i].split('||')[0] x = float(point.split('|')[0]) y = float(point.split('|')[1]) #print x,y,z # Calcolo cost (sostituire i punti di partenza in start_raster al pusto di punto) grass.run_command('r.cost', flags="k", input='uno', output='costo', start_coordinates=str(x) + ',' + str(y), quiet=True, overwrite=True) #trasforma i valori di distanza celle in valori metrici utilizzando la risoluzione raster grass.mapcalc('costo_m=costo*(ewres()+nsres())/2', overwrite=True) # calcola A=tangente angolo visuale (INPUT) * costo in metri grass.mapcalc('A=tan($ang)*costo_m', ang=ang, overwrite=True) grass.mapcalc('C=$z-A', z=z, overwrite=True) grass.mapcalc('D=C-$dem', dem=r_elevation, overwrite=True) # area di espansione grass.mapcalc('E=if(D>0,1,null())', overwrite=True) # valore di deltaH (F) grass.mapcalc('F=D*E', overwrite=True) # calcolo velocita grass.mapcalc('vel = $red*sqrt(2*9.8*F)', red=red, overwrite=True) velocity.read('vel') velMax[...] = (np.where(velocity > velMax, velocity, velMax)).astype(float) velMean[...] = (velocity + velMean).astype(float) #calcolo numero massi grass.mapcalc('somma=if(vel>0,1,0)', overwrite=True) somma.read('somma') tot[...] = (somma + tot).astype(float) # calcolo energia grass.mapcalc('en=$m*9.8*F/1000', m=m, overwrite=True) energy.read('en') enMax[...] = (np.where(energy > enMax, energy, enMax)).astype(float) enMean[...] = (energy + enMean).astype(float) grass.message("Create output maps...") tot.write(rocks) velMax.write(vMax) velMean[...] = (velMean / i).astype(float) velMean.write(vMean) enMax.write(eMax) enMean[...] = (enMean / i).astype(float) enMean.write(eMean) #grass.run_command('d.mon', # start = 'wx0') #grass.run_command('d.rast' , # map=vMax) #grass.run_command('d.rast' , # map=vMean) #grass.run_command('d.rast' , # map=eMax) #grass.run_command('d.rast' , # map=eMean) if int(num) == 1: grass.run_command('g.remove', flags='f', type='vector', name=('start_points_'), quiet=True) else: grass.run_command('g.rename', vect='start_points_,' + prefix + '_starting', quiet=True) grass.run_command('g.remove', flags='f', type='vector', name=('start_buffer_', 'start_random_'), quiet=True) grass.run_command('g.remove', flags='f', type='raster', name=('uno', 'costo', 'costo_m', 'A', 'C', 'D', 'E', 'F', 'en', 'vel', 'somma'), quiet=True) grass.message("Done!")
def main(): if not hasNumPy: grass.fatal(_("Required dependency NumPy not found. Exiting.")) sharpen = options["method"] # sharpening algorithm ms1_orig = options["blue"] # blue channel ms2_orig = options["green"] # green channel ms3_orig = options["red"] # red channel pan_orig = options["pan"] # high res pan channel out = options["output"] # prefix for output RGB maps bits = options["bitdepth"] # bit depth of image channels bladjust = flags["l"] # adjust blue channel sproc = flags["s"] # serial processing rescale = flags["r"] # rescale to spread pixel values to entire 0-255 range # Checking bit depth bits = float(bits) if bits < 2 or bits > 30: grass.warning(_("Bit depth is outside acceptable range")) return outb = grass.core.find_file("%s_blue" % out) outg = grass.core.find_file("%s_green" % out) outr = grass.core.find_file("%s_red" % out) if ( outb["name"] != "" or outg["name"] != "" or outr["name"] != "" ) and not grass.overwrite(): grass.warning( _( "Maps with selected output prefix names already exist." " Delete them or use overwrite flag" ) ) return pid = str(os.getpid()) # convert input image channels to 8 bit for processing ms1 = "tmp%s_ms1" % pid ms2 = "tmp%s_ms2" % pid ms3 = "tmp%s_ms3" % pid pan = "tmp%s_pan" % pid if not rescale: if bits == 8: grass.message(_("Using 8bit image channels")) if sproc: # serial processing grass.run_command( "g.copy", raster="%s,%s" % (ms1_orig, ms1), quiet=True, overwrite=True, ) grass.run_command( "g.copy", raster="%s,%s" % (ms2_orig, ms2), quiet=True, overwrite=True, ) grass.run_command( "g.copy", raster="%s,%s" % (ms3_orig, ms3), quiet=True, overwrite=True, ) grass.run_command( "g.copy", raster="%s,%s" % (pan_orig, pan), quiet=True, overwrite=True, ) else: # parallel processing pb = grass.start_command( "g.copy", raster="%s,%s" % (ms1_orig, ms1), quiet=True, overwrite=True, ) pg = grass.start_command( "g.copy", raster="%s,%s" % (ms2_orig, ms2), quiet=True, overwrite=True, ) pr = grass.start_command( "g.copy", raster="%s,%s" % (ms3_orig, ms3), quiet=True, overwrite=True, ) pp = grass.start_command( "g.copy", raster="%s,%s" % (pan_orig, pan), quiet=True, overwrite=True, ) pb.wait() pg.wait() pr.wait() pp.wait() else: grass.message(_("Converting image chanels to 8bit for processing")) maxval = pow(2, bits) - 1 if sproc: # serial processing grass.run_command( "r.rescale", input=ms1_orig, from_="0,%f" % maxval, output=ms1, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=ms2_orig, from_="0,%f" % maxval, output=ms2, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=ms3_orig, from_="0,%f" % maxval, output=ms3, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=pan_orig, from_="0,%f" % maxval, output=pan, to="0,255", quiet=True, overwrite=True, ) else: # parallel processing pb = grass.start_command( "r.rescale", input=ms1_orig, from_="0,%f" % maxval, output=ms1, to="0,255", quiet=True, overwrite=True, ) pg = grass.start_command( "r.rescale", input=ms2_orig, from_="0,%f" % maxval, output=ms2, to="0,255", quiet=True, overwrite=True, ) pr = grass.start_command( "r.rescale", input=ms3_orig, from_="0,%f" % maxval, output=ms3, to="0,255", quiet=True, overwrite=True, ) pp = grass.start_command( "r.rescale", input=pan_orig, from_="0,%f" % maxval, output=pan, to="0,255", quiet=True, overwrite=True, ) pb.wait() pg.wait() pr.wait() pp.wait() else: grass.message(_("Rescaling image chanels to 8bit for processing")) min_ms1 = int(grass.raster_info(ms1_orig)["min"]) max_ms1 = int(grass.raster_info(ms1_orig)["max"]) min_ms2 = int(grass.raster_info(ms2_orig)["min"]) max_ms2 = int(grass.raster_info(ms2_orig)["max"]) min_ms3 = int(grass.raster_info(ms3_orig)["min"]) max_ms3 = int(grass.raster_info(ms3_orig)["max"]) min_pan = int(grass.raster_info(pan_orig)["min"]) max_pan = int(grass.raster_info(pan_orig)["max"]) maxval = pow(2, bits) - 1 if sproc: # serial processing grass.run_command( "r.rescale", input=ms1_orig, from_="%f,%f" % (min_ms1, max_ms1), output=ms1, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=ms2_orig, from_="%f,%f" % (min_ms2, max_ms2), output=ms2, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=ms3_orig, from_="%f,%f" % (min_ms3, max_ms3), output=ms3, to="0,255", quiet=True, overwrite=True, ) grass.run_command( "r.rescale", input=pan_orig, from_="%f,%f" % (min_pan, max_pan), output=pan, to="0,255", quiet=True, overwrite=True, ) else: # parallel processing pb = grass.start_command( "r.rescale", input=ms1_orig, from_="%f,%f" % (min_ms1, max_ms1), output=ms1, to="0,255", quiet=True, overwrite=True, ) pg = grass.start_command( "r.rescale", input=ms2_orig, from_="%f,%f" % (min_ms2, max_ms2), output=ms2, to="0,255", quiet=True, overwrite=True, ) pr = grass.start_command( "r.rescale", input=ms3_orig, from_="%f,%f" % (min_ms3, max_ms3), output=ms3, to="0,255", quiet=True, overwrite=True, ) pp = grass.start_command( "r.rescale", input=pan_orig, from_="%f,%f" % (min_pan, max_pan), output=pan, to="0,255", quiet=True, overwrite=True, ) pb.wait() pg.wait() pr.wait() pp.wait() # get PAN resolution: kv = grass.raster_info(map=pan) nsres = kv["nsres"] ewres = kv["ewres"] panres = (nsres + ewres) / 2 # clone current region grass.use_temp_region() grass.run_command("g.region", res=panres, align=pan) # Select sharpening method grass.message(_("Performing pan sharpening with hi res pan image: %f" % panres)) if sharpen == "brovey": brovey(pan, ms1, ms2, ms3, out, pid, sproc) elif sharpen == "ihs": ihs(pan, ms1, ms2, ms3, out, pid, sproc) elif sharpen == "pca": pca(pan, ms1, ms2, ms3, out, pid, sproc) # Could add other sharpening algorithms here, e.g. wavelet transformation grass.message(_("Assigning grey equalized color tables to output images...")) # equalized grey scales give best contrast grass.message(_("setting pan-sharpened channels to equalized grey scale")) for ch in ["red", "green", "blue"]: grass.run_command( "r.colors", quiet=True, map="%s_%s" % (out, ch), flags="e", color="grey" ) # Landsat too blue-ish because panchromatic band less sensitive to blue # light, so output blue channed can be modified if bladjust: grass.message(_("Adjusting blue channel color table...")) blue_colors = ["0 0 0 0\n5% 0 0 0\n67% 255 255 255\n100% 255 255 255"] # these previous colors are way too blue for landsat # blue_colors = ['0 0 0 0\n10% 0 0 0\n20% 200 200 200\n40% 230 230 230\n67% 255 255 255\n100% 255 255 255'] bc = grass.feed_command("r.colors", quiet=True, map="%s_blue" % out, rules="-") bc.stdin.write(grass.encode("\n".join(blue_colors))) bc.stdin.close() # output notice grass.verbose(_("The following pan-sharpened output maps have been generated:")) for ch in ["red", "green", "blue"]: grass.verbose(_("%s_%s") % (out, ch)) grass.verbose(_("To visualize output, run: g.region -p raster=%s_red" % out)) grass.verbose(_("d.rgb r=%s_red g=%s_green b=%s_blue" % (out, out, out))) grass.verbose( _("If desired, combine channels into a single RGB map with 'r.composite'.") ) grass.verbose(_("Channel colors can be rebalanced using i.colors.enhance.")) # write cmd history: for ch in ["red", "green", "blue"]: grass.raster_history("%s_%s" % (out, ch)) # create a group with the three outputs # grass.run_command('i.group', group=out, # input="{n}_red,{n}_blue,{n}_green".format(n=out)) # Cleanup grass.message(_("cleaning up temp files")) try: grass.run_command( "g.remove", flags="f", type="raster", pattern="tmp%s*" % pid, quiet=True ) except: ""
def pca(pan, ms1, ms2, ms3, out, pid, sproc): grass.verbose(_("Using PCA/inverse PCA algorithm")) grass.message(_("Creating PCA images and calculating eigenvectors...")) # initial PCA with RGB channels pca_out = grass.read_command( "i.pca", quiet=True, rescale="0,0", input="%s,%s,%s" % (ms1, ms2, ms3), output="tmp%s.pca" % pid, ) if len(pca_out) < 1: grass.fatal(_("Input has no data. Check region settings.")) b1evect = [] b2evect = [] b3evect = [] for l in pca_out.replace("(", ",").replace(")", ",").splitlines(): b1evect.append(float(l.split(",")[1])) b2evect.append(float(l.split(",")[2])) b3evect.append(float(l.split(",")[3])) # inverse PCA with hi res pan channel substituted for principal component 1 pca1 = "tmp%s.pca.1" % pid pca2 = "tmp%s.pca.2" % pid pca3 = "tmp%s.pca.3" % pid b1evect1 = b1evect[0] b1evect2 = b1evect[1] b1evect3 = b1evect[2] b2evect1 = b2evect[0] b2evect2 = b2evect[1] b2evect3 = b2evect[2] b3evect1 = b3evect[0] b3evect2 = b3evect[1] b3evect3 = b3evect[2] # Histogram matching outname = "tmp%s_pan1" % pid panmatch1 = matchhist(pan, ms1, outname) outname = "tmp%s_pan2" % pid panmatch2 = matchhist(pan, ms2, outname) outname = "tmp%s_pan3" % pid panmatch3 = matchhist(pan, ms3, outname) grass.message(_("Performing inverse PCA ...")) # Get mean value of each channel stats1 = grass.parse_command( "r.univar", map=ms1, flags="g", parse=(grass.parse_key_val, {"sep": "="}) ) stats2 = grass.parse_command( "r.univar", map=ms2, flags="g", parse=(grass.parse_key_val, {"sep": "="}) ) stats3 = grass.parse_command( "r.univar", map=ms3, flags="g", parse=(grass.parse_key_val, {"sep": "="}) ) b1mean = float(stats1["mean"]) b2mean = float(stats2["mean"]) b3mean = float(stats3["mean"]) if sproc: # serial processing outr = "%s_red" % out outg = "%s_green" % out outb = "%s_blue" % out cmd1 = "$outb = 1 * round(($panmatch1 * $b1evect1) + ($pca2 * $b1evect2) + ($pca3 * $b1evect3) + $b1mean)" cmd2 = "$outg = 1 * round(($panmatch2 * $b2evect1) + ($pca2 * $b2evect2) + ($pca3 * $b2evect3) + $b2mean)" cmd3 = "$outr = 1 * round(($panmatch3 * $b3evect1) + ($pca2 * $b3evect2) + ($pca3 * $b3evect3) + $b3mean)" cmd = "\n".join([cmd1, cmd2, cmd3]) grass.mapcalc( cmd, outb=outb, outg=outg, outr=outr, panmatch1=panmatch1, panmatch2=panmatch2, panmatch3=panmatch3, pca2=pca2, pca3=pca3, b1evect1=b1evect1, b2evect1=b2evect1, b3evect1=b3evect1, b1evect2=b1evect2, b2evect2=b2evect2, b3evect2=b3evect2, b1evect3=b1evect3, b2evect3=b2evect3, b3evect3=b3evect3, b1mean=b1mean, b2mean=b2mean, b3mean=b3mean, overwrite=True, ) else: # parallel processing pb = grass.mapcalc_start( "%s_blue = 1 * round((%s * %f) + (%s * %f) + (%s * %f) + %f)" % (out, panmatch1, b1evect1, pca2, b1evect2, pca3, b1evect3, b1mean), overwrite=True, ) pg = grass.mapcalc_start( "%s_green = 1 * round((%s * %f) + (%s * %f) + (%s * %f) + %f)" % (out, panmatch2, b2evect1, pca2, b2evect2, pca3, b2evect3, b2mean), overwrite=True, ) pr = grass.mapcalc_start( "%s_red = 1 * round((%s * %f) + (%s * %f) + (%s * %f) + %f)" % (out, panmatch3, b3evect1, pca2, b3evect2, pca3, b3evect3, b3mean), overwrite=True, ) pb.wait(), pg.wait(), pr.wait() try: pb.terminate(), pg.terminate(), pr.terminate() except: "" # Cleanup grass.run_command( "g.remove", flags="f", quiet=True, type="raster", name="%s,%s,%s" % (panmatch1, panmatch2, panmatch3), )
def reclass(inf, outf, lim, clump, diag, les): infile = inf outfile = outf lesser = les limit = lim clumped = clump diagonal = diag s = grass.read_command("g.region", flags='p') s = decode(s) kv = grass.parse_key_val(s, sep=':') s = kv['projection'].strip().split() if s == '0': grass.fatal(_("xy-locations are not supported")) grass.fatal(_("Need projected data with grids in meters")) if not grass.find_file(infile)['name']: grass.fatal(_("Raster map <%s> not found") % infile) if clumped and diagonal: grass.fatal(_("flags c and d are mutually exclusive")) if clumped: clumpfile = infile else: clumpfile = "%s.clump.%s" % (infile.split('@')[0], outfile) TMPRAST.append(clumpfile) if not grass.overwrite(): if grass.find_file(clumpfile)['name']: grass.fatal(_("Temporary raster map <%s> exists") % clumpfile) if diagonal: grass.message( _("Generating a clumped raster file including " "diagonal neighbors...")) grass.run_command('r.clump', flags='d', input=infile, output=clumpfile) else: grass.message(_("Generating a clumped raster file ...")) grass.run_command('r.clump', input=infile, output=clumpfile) if lesser: grass.message( _("Generating a reclass map with area size less than " "or equal to %f hectares...") % limit) else: grass.message( _("Generating a reclass map with area size greater " "than or equal to %f hectares...") % limit) recfile = outfile + '.recl' TMPRAST.append(recfile) sflags = 'aln' if grass.raster_info(infile)['datatype'] in ('FCELL', 'DCELL'): sflags += 'i' p1 = grass.pipe_command('r.stats', flags=sflags, input=(clumpfile, infile), sep=';') p2 = grass.feed_command('r.reclass', input=clumpfile, output=recfile, rules='-') rules = '' for line in p1.stdout: f = decode(line).rstrip(os.linesep).split(';') if len(f) < 5: continue hectares = float(f[4]) * 0.0001 if lesser: test = hectares <= limit else: test = hectares >= limit if test: rules += "%s = %s %s\n" % (f[0], f[2], f[3]) if rules: p2.stdin.write(encode(rules)) p1.wait() p2.stdin.close() p2.wait() if p2.returncode != 0: if lesser: grass.fatal( _("No areas of size less than or equal to %f " "hectares found.") % limit) else: grass.fatal( _("No areas of size greater than or equal to %f " "hectares found.") % limit) grass.mapcalc("$outfile = $recfile", outfile=outfile, recfile=recfile)
def main(): global tile, tmpdir, in_temp in_temp = False input = options['input'] output = options['output'] one = flags['1'] #are we in LatLong location? s = grass.read_command("g.proj", flags='j') kv = grass.parse_key_val(s) if kv['+proj'] != 'longlat': grass.fatal(_("This module only operates in LatLong locations")) # use these from now on: infile = input while infile[-4:].lower() in ['.hgt', '.zip']: infile = infile[:-4] (fdir, tile) = os.path.split(infile) if not output: tileout = tile else: tileout = output zipfile = infile + ".hgt.zip" hgtfile = os.path.join(fdir, tile[:7] + ".hgt") if os.path.isfile(zipfile): #### check if we have unzip if not grass.find_program('unzip'): grass.fatal( _('The "unzip" program is required, please install it first')) # really a ZIP file? # make it quiet in a safe way (just in case -qq isn't portable) tenv = os.environ.copy() tenv['UNZIP'] = '-qq' if grass.call(['unzip', '-t', zipfile], env=tenv) != 0: grass.fatal( _("'%s' does not appear to be a valid zip file.") % zipfile) is_zip = True elif os.path.isfile(hgtfile): # try and see if it's already unzipped is_zip = False else: grass.fatal(_("File '%s' or '%s' not found") % (zipfile, hgtfile)) #make a temporary directory tmpdir = grass.tempfile() grass.try_remove(tmpdir) os.mkdir(tmpdir) if is_zip: shutil.copyfile(zipfile, os.path.join(tmpdir, tile + ".hgt.zip")) else: shutil.copyfile(hgtfile, os.path.join(tmpdir, tile + ".hgt")) #change to temporary directory os.chdir(tmpdir) in_temp = True zipfile = tile + ".hgt.zip" hgtfile = tile[:7] + ".hgt" bilfile = tile + ".bil" if is_zip: #unzip & rename data file: grass.message(_("Extracting '%s'...") % infile) if grass.call(['unzip', zipfile], env=tenv) != 0: grass.fatal(_("Unable to unzip file.")) grass.message(_("Converting input file to BIL...")) os.rename(hgtfile, bilfile) north = tile[0] ll_latitude = int(tile[1:3]) east = tile[3] ll_longitude = int(tile[4:7]) # are we on the southern hemisphere? If yes, make LATITUDE negative. if north == "S": ll_latitude *= -1 # are we west of Greenwich? If yes, make LONGITUDE negative. if east == "W": ll_longitude *= -1 # Calculate Upper Left from Lower Left ulxmap = "%.1f" % ll_longitude # SRTM90 tile size is 1 deg: ulymap = "%.1f" % (ll_latitude + 1) if not one: tmpl = tmpl3sec else: grass.message(_("Attempting to import 1-arcsec data.")) tmpl = tmpl1sec header = tmpl % (ulxmap, ulymap) hdrfile = tile + '.hdr' outf = file(hdrfile, 'w') outf.write(header) outf.close() #create prj file: To be precise, we would need EGS96! But who really cares... prjfile = tile + '.prj' outf = file(prjfile, 'w') outf.write(proj) outf.close() if grass.run_command('r.in.gdal', input=bilfile, out=tileout) != 0: grass.fatal(_("Unable to import data")) # nice color table grass.run_command('r.colors', map=tileout, color='srtm') # write cmd history: grass.raster_history(tileout) grass.message(_("Done: generated map ") + tileout) grass.message( _("(Note: Holes in the data can be closed with 'r.fillnulls' using splines)" ))
def main(): # lazy imports import grass.temporal as tgis # Get the options input = options["input"] where = options["where"] columns = options["columns"] tempwhere = options["t_where"] layer = options["layer"] separator = grass.separator(options["separator"]) if where == "" or where == " " or where == "\n": where = None if columns == "" or columns == " " or columns == "\n": columns = None # Make sure the temporal database exists tgis.init() sp = tgis.open_old_stds(input, "stvds") rows = sp.get_registered_maps("name,layer,mapset,start_time,end_time", tempwhere, "start_time", None) col_names = "" if rows: for row in rows: vector_name = "%s@%s" % (row["name"], row["mapset"]) # In case a layer is defined in the vector dataset, # we override the option layer if row["layer"]: layer = row["layer"] select = grass.read_command("v.db.select", map=vector_name, layer=layer, columns=columns, separator="%s" % (separator), where=where) if not select: grass.fatal( _("Unable to run v.db.select for vector map <%s> " "with layer %s") % (vector_name, layer)) # The first line are the column names list = select.split("\n") count = 0 for entry in list: if entry.strip() != "": # print the column names in case they change if count == 0: col_names_new = "start_time%send_time%s%s" % ( separator, separator, entry) if col_names != col_names_new: col_names = col_names_new print(col_names) else: if row["end_time"]: print("%s%s%s%s%s" % (row["start_time"], separator, row["end_time"], separator, entry)) else: print("%s%s%s%s" % (row["start_time"], separator, separator, entry)) count += 1
(C) 2012 by the GRASS Development Team This program is free software under the GNU General Public License (>=v2). Read the file COPYING that comes with GRASS for details. @author Stepan Turek <stepan.turek seznam.cz> (Mentor: Martin Landa) """ import os import grass.script as grass try: from osgeo import gdal from osgeo import gdalconst except: grass.fatal(_("Unable to load GDAL Python bindings")) import xml.etree.ElementTree as etree from wms_base import WMSBase class NullDevice(): def write(self, s): pass class WMSGdalDrv(WMSBase): def _createXML(self): """!Create XML for GDAL WMS driver
def main(): vector = options['map'] layer = options['layer'] column = options['column'] value = options['value'] qcolumn = options['query_column'] where = options['where'] sqlitefile = options['sqliteextra'] mapset = grass.gisenv()['MAPSET'] # does map exist in CURRENT mapset? if not grass.find_file(vector, element='vector', mapset=mapset)['file']: grass.fatal(_("Vector map <%s> not found in current mapset") % vector) try: f = grass.vector_db(vector)[int(layer)] except KeyError: grass.fatal( _('There is no table connected to this map. Run v.db.connect or v.db.addtable first.' )) table = f['table'] database = f['database'] driver = f['driver'] # check for SQLite backend for extra functions if sqlitefile and driver != "sqlite": grass.fatal(_("Use of libsqlitefunctions only with SQLite backend")) if driver == "sqlite" and sqlitefile: if not os.access(sqlitefile, os.R_OK): grass.fatal(_("File <%s> not found") % sqlitefile) # checking column types try: coltype = grass.vector_columns(vector, layer)[column]['type'] except KeyError: grass.fatal(_('Column <%s> not found') % column) if qcolumn: if value: grass.fatal(_('<value> and <qcolumn> are mutually exclusive')) # special case: we copy from another column value = qcolumn else: if not value: grass.fatal(_('Either <value> or <qcolumn> must be given')) # we insert a value if coltype.upper() not in ["INTEGER", "DOUBLE PRECISION"]: value = "'%s'" % value cmd = "UPDATE %s SET %s=%s" % (table, column, value) if where: cmd += " WHERE " + where # SQLite: preload extra functions from extension lib if provided by user if sqlitefile: sqliteload = "SELECT load_extension('%s');\n" % sqlitefile cmd = sqliteload + cmd grass.verbose("SQL: \"%s\"" % cmd) grass.write_command('db.execute', input='-', database=database, driver=driver, stdin=cmd) # write cmd history: grass.vector_history(vector) return 0
def main(): user = password = None api_url = 'https://scihub.copernicus.eu/dhus' if options['settings'] == '-': # stdin import getpass user = raw_input(_('Insert username: '******'Insert password: '******'Insert API URL (leave empty for {}): ').format(api_url)) if url: api_url = url else: try: with open(options['settings'], 'r') as fd: lines = list(filter(None, (line.rstrip() for line in fd))) # non-blank lines only if len(lines) < 2: gs.fatal(_("Invalid settings file")) user = lines[0].strip() password = lines[1].strip() if len(lines) > 2: api_url = lines[2].strip() except IOError as e: gs.fatal(_("Unable to open settings file: {}").format(e)) if user is None or password is None: gs.fatal(_("No user or password given")) map_box = get_aoi_box(options['map']) sortby = options['sort'].split(',') if options['producttype'] in ('SLC', 'GRD', 'OCN'): if options['clouds']: gs.info("Option <{}> ignored: cloud cover percentage " "is not defined for product type {}".format( "clouds", options['producttype'])) options['clouds'] = None try: sortby.remove('cloudcoverpercentage') except ValueError: pass try: downloader = SentinelDownloader(user, password, api_url) if options['uuid']: downloader.set_uuid(options['uuid'].split(',')) else: query = {} if options['query']: for item in options['query'].split(','): k, v = item.split('=') query[k] = v downloader.filter(area=map_box, area_relation=options['area_relation'], clouds=options['clouds'], producttype=options['producttype'], limit=options['limit'], query=query, start=options['start'], end=options['end'], sortby=sortby, asc=options['order'] == 'asc') except StandardError as e: gs.fatal( _('Unable to connect Copernicus Open Access Hub: {}').format(e)) if options['footprints']: downloader.save_footprints(options['footprints']) if flags['l']: downloader.list() return downloader.download(options['output']) return 0
This program is free software under the GNU General Public License (>=v2). Read the file COPYING that comes with GRASS for details. @author Stepan Turek <stepan.turek seznam.cz> (Mentor: Martin Landa) """ import socket import grass.script as grass from time import sleep try: from osgeo import gdal except: grass.fatal( _("Unable to load GDAL Python bindings (requires package 'python-gdal' being installed)" )) import numpy as Numeric Numeric.arrayrange = Numeric.arange from math import pi, floor try: from urllib2 import HTTPError from httplib import HTTPException except ImportError: # python3 from urllib.error import HTTPError from http.client import HTTPException
def _download(self): """!Downloads data from WMS server using own driver @return temp_map with downloaded data """ grass.message(_("Downloading data from WMS server...")) server_url = self.params["url"] if "?" in self.params["url"]: self.params["url"] += "&" else: self.params["url"] += "?" if not self.params["capfile"]: self.cap_file = self._fetchCapabilities(self.params) else: self.cap_file = self.params["capfile"] # initialize correct manager according to chosen OGC service if self.params["driver"] == "WMTS_GRASS": req_mgr = WMTSRequestMgr(self.params, self.bbox, self.region, self.proj_srs, self.cap_file) elif self.params["driver"] == "WMS_GRASS": req_mgr = WMSRequestMgr(self.params, self.bbox, self.region, self.tile_size, self.proj_srs) elif self.params["driver"] == "OnEarth_GRASS": req_mgr = OnEarthRequestMgr(self.params, self.bbox, self.region, self.proj_srs, self.cap_file) # get information about size in pixels and bounding box of raster, where # all tiles will be joined map_region = req_mgr.GetMapRegion() init = True temp_map = None fetch_try = 0 # iterate through all tiles and download them while True: if fetch_try == 0: # get url for request the tile and information for placing the tile into # raster with other tiles tile = req_mgr.GetNextTile() # if last tile has been already downloaded if not tile: break # url for request the tile query_url = tile[0] # the tile size and offset in pixels for placing it into raster where tiles are joined tile_ref = tile[1] grass.debug(query_url, 2) try: wms_data = self._fetchDataFromServer(query_url, self.params["username"], self.params["password"]) except (IOError, HTTPException) as e: if isinstance(e, HTTPError) and e.code == 401: grass.fatal( _("Authorization failed to '%s' when fetching data.\n%s" ) % (self.params["url"], str(e))) else: grass.fatal( _("Unable to fetch data from: '%s'\n%s") % (self.params["url"], str(e))) temp_tile = self._tempfile() # download data into temporary file try: temp_tile_opened = open(temp_tile, "wb") temp_tile_opened.write(wms_data.read()) except IOError as e: # some servers are not happy with many subsequent requests for tiles done immediately, # if immediate request was unsuccessful, try to repeat the request after 5s and 30s breaks # TODO probably servers can return more kinds of errors related to this # problem (not only 104) if isinstance(e, socket.error) and e[0] == 104 and fetch_try < 2: fetch_try += 1 if fetch_try == 1: sleep_time = 5 elif fetch_try == 2: sleep_time = 30 grass.warning( _("Server refused to send data for a tile.\nRequest will be repeated after %d s." ) % sleep_time) sleep(sleep_time) continue else: grass.fatal( _("Unable to write data into tempfile.\n%s") % str(e)) finally: temp_tile_opened.close() fetch_try = 0 tile_dataset_info = gdal.Open(temp_tile, gdal.GA_ReadOnly) if tile_dataset_info is None: # print error xml returned from server try: error_xml_opened = open(temp_tile, "rb") err_str = error_xml_opened.read() except IOError as e: grass.fatal( _("Unable to read data from tempfile.\n%s") % str(e)) finally: error_xml_opened.close() if err_str is not None: grass.fatal(_("WMS server error: %s") % err_str) else: grass.fatal(_("WMS server unknown error")) temp_tile_pct2rgb = None if tile_dataset_info.RasterCount < 1: grass.fatal( _("WMS server error: no band(s) received. Is server URL correct? <%s>" ) % server_url) if (tile_dataset_info.RasterCount == 1 and tile_dataset_info.GetRasterBand(1).GetRasterColorTable() is not None): # expansion of color table into bands temp_tile_pct2rgb = self._tempfile() tile_dataset = self._pct2rgb(temp_tile, temp_tile_pct2rgb) else: tile_dataset = tile_dataset_info # initialization of temp_map_dataset, where all tiles are merged if init: temp_map = self._tempfile() driver = gdal.GetDriverByName(self.gdal_drv_format) metadata = driver.GetMetadata() if (gdal.DCAP_CREATE not in metadata or metadata[gdal.DCAP_CREATE] == "NO"): grass.fatal( _("Driver %s does not supports Create() method") % self.gdal_drv_format) self.temp_map_bands_num = tile_dataset.RasterCount temp_map_dataset = driver.Create( temp_map, map_region["cols"], map_region["rows"], self.temp_map_bands_num, tile_dataset.GetRasterBand(1).DataType, ) init = False # tile is written into temp_map tile_to_temp_map = tile_dataset.ReadRaster( 0, 0, tile_ref["sizeX"], tile_ref["sizeY"], tile_ref["sizeX"], tile_ref["sizeY"], ) temp_map_dataset.WriteRaster( tile_ref["t_cols_offset"], tile_ref["t_rows_offset"], tile_ref["sizeX"], tile_ref["sizeY"], tile_to_temp_map, ) tile_dataset = None tile_dataset_info = None grass.try_remove(temp_tile) grass.try_remove(temp_tile_pct2rgb) if not temp_map: return temp_map # georeferencing and setting projection of temp_map projection = grass.read_command("g.proj", flags="wf", epsg=GetEpsg(self.params["srs"])) projection = projection.rstrip("\n") temp_map_dataset.SetProjection(projection) pixel_x_length = (map_region["maxx"] - map_region["minx"]) / int( map_region["cols"]) pixel_y_length = (map_region["miny"] - map_region["maxy"]) / int( map_region["rows"]) geo_transform = [ map_region["minx"], pixel_x_length, 0.0, map_region["maxy"], 0.0, pixel_y_length, ] temp_map_dataset.SetGeoTransform(geo_transform) temp_map_dataset = None return temp_map
def _computeBbox(self): """!Get region extent for WMS query (bbox) """ self._debug("_computeBbox", "started") bbox_region_items = { 'maxy': 'n', 'miny': 's', 'maxx': 'e', 'minx': 'w' } bbox = {} if self.proj_srs == self.proj_location: # TODO: do it better for bbox_item, region_item in bbox_region_items.items(): bbox[bbox_item] = self.region[region_item] # if location projection and wms query projection are # different, corner points of region are transformed into wms # projection and then bbox is created from extreme coordinates # of the transformed points else: for bbox_item, region_item in bbox_region_items.items(): bbox[bbox_item] = None temp_region = self._tempfile() try: temp_region_opened = open(temp_region, 'w') temp_region_opened.write( "%f %f\n%f %f\n%f %f\n%f %f\n" % (self.region['e'], self.region['n'], self.region['w'], self.region['n'], self.region['w'], self.region['s'], self.region['e'], self.region['s'])) except IOError: grass.fatal(_("Unable to write data into tempfile")) finally: temp_region_opened.close() points = grass.read_command('m.proj', flags='d', proj_out=self.proj_srs, proj_in=self.proj_location, input=temp_region, quiet=True) # TODO: stdin grass.try_remove(temp_region) if not points: grass.fatal( _("Unable to determine region, %s failed") % 'm.proj') points = points.splitlines() if len(points) != 4: grass.fatal(_("Region definition: 4 points required")) for point in points: try: point = list(map(float, point.split("|"))) except ValueError: grass.fatal( _('Reprojection of region using m.proj failed.')) if not bbox['maxy']: bbox['maxy'] = point[1] bbox['miny'] = point[1] bbox['maxx'] = point[0] bbox['minx'] = point[0] continue if bbox['maxy'] < point[1]: bbox['maxy'] = point[1] elif bbox['miny'] > point[1]: bbox['miny'] = point[1] if bbox['maxx'] < point[0]: bbox['maxx'] = point[0] elif bbox['minx'] > point[0]: bbox['minx'] = point[0] self._debug("_computeBbox", "finished -> %s" % bbox) # Ordering of coordinates axis of geographic coordinate # systems in WMS 1.3.0 is flipped. If self.tile_size['flip_coords'] is # True, coords in bbox need to be flipped in WMS query. return bbox
def main(): mapname = options['map'] option = options['option'] layer = options['layer'] units = options['units'] nuldev = file(os.devnull, 'w') if not grass.find_file(mapname, 'vector')['file']: grass.fatal(_("Vector map <%s> not found") % mapname) if int(layer) in grass.vector_db(mapname): colnames = grass.vector_columns(mapname, layer, getDict=False, stderr=nuldev) isConnection = True else: isConnection = False colnames = ['cat'] if option == 'coor': extracolnames = ['x', 'y', 'z'] else: extracolnames = [option] if units == 'percent': unitsp = 'meters' elif units: unitsp = units else: unitsp = None # NOTE: we suppress -1 cat and 0 cat if isConnection: f = grass.vector_db(map=mapname)[int(layer)] p = grass.pipe_command('v.db.select', quiet=True, map=mapname, layer=layer) records1 = [] catcol = -1 for line in p.stdout: cols = line.rstrip('\r\n').split('|') if catcol == -1: for i in range(0, len(cols)): if cols[i] == f['key']: catcol = i break if catcol == -1: grass.fatal( _("There is a table connected to input vector map '%s', but " "there is no key column '%s'.") % (mapname, f['key'])) continue if cols[catcol] == '-1' or cols[catcol] == '0': continue records1.append(cols[:catcol] + [int(cols[catcol])] + cols[(catcol + 1):]) p.wait() if p.returncode != 0: sys.exit(1) records1.sort(key=lambda r: r[catcol]) if len(records1) == 0: try: grass.fatal( _("There is a table connected to input vector map '%s', but " "there are no categories present in the key column '%s'. Consider using " "v.to.db to correct this.") % (mapname, f['key'])) except KeyError: pass # fetch the requested attribute sorted by cat: p = grass.pipe_command('v.to.db', flags='p', quiet=True, map=mapname, option=option, layer=layer, units=unitsp) records2 = [] for line in p.stdout: fields = line.rstrip('\r\n').split('|') if fields[0] in ['cat', '-1', '0']: continue records2.append([int(fields[0])] + fields[1:]) p.wait() records2.sort() # make pre-table # len(records1) may not be the same as len(records2) because # v.db.select can return attributes that are not linked to features. records3 = [] for r2 in records2: records3.append( filter(lambda r1: r1[catcol] == r2[0], records1)[0] + r2[1:]) else: catcol = 0 records1 = [] p = grass.pipe_command('v.category', inp=mapname, layer=layer, option='print') for line in p.stdout: field = int(line.rstrip()) if field > 0: records1.append(field) p.wait() records1.sort() records1 = uniq(records1) # make pre-table p = grass.pipe_command('v.to.db', flags='p', quiet=True, map=mapname, option=option, layer=layer, units=unitsp) records3 = [] for line in p.stdout: fields = line.rstrip('\r\n').split('|') if fields[0] in ['cat', '-1', '0']: continue records3.append([int(fields[0])] + fields[1:]) p.wait() records3.sort() # print table header sys.stdout.write('|'.join(colnames + extracolnames) + '\n') # make and print the table: numcols = len(colnames) + len(extracolnames) # calculate percents if requested if units == 'percent' and option != 'coor': # calculate total value total = 0 for r in records3: total += float(r[-1]) # calculate percentages records4 = [float(r[-1]) * 100 / total for r in records3] if type(records1[0]) == int: records3 = [[r1] + [r4] for r1, r4 in zip(records1, records4)] else: records3 = [r1 + [r4] for r1, r4 in zip(records1, records4)] # sort results if options['sort']: if options['sort'] == 'asc': if options['option'] == 'coor': records3.sort( key=lambda r: (float(r[-3]), float(r[-2]), float(r[-1]))) else: records3.sort(key=lambda r: float(r[-1])) else: if options['option'] == 'coor': records3.sort(key=lambda r: (float(r[-3]), float(r[-2]), float(r[-1])), reverse=True) else: records3.sort(key=lambda r: float(r[-1]), reverse=True) for r in records3: sys.stdout.write('|'.join(map(str, r)) + '\n')
def _reprojectMap(self): """!Reproject data using gdalwarp if needed """ # reprojection of raster do_reproject = True if self.source_epsg is not None and self.target_epsg is not None \ and self.source_epsg == self.target_epsg: do_reproject = False # TODO: correctly compare source and target crs if do_reproject == True and self.proj_srs == self.proj_location: do_reproject = False if do_reproject: grass.message(_("Reprojecting raster...")) self.temp_warpmap = grass.tempfile() + '.tif' if int(os.getenv('GRASS_VERBOSE', '2')) <= 2: nuldev = open(os.devnull, 'w+') else: nuldev = None if self.params['method'] == "nearest": gdal_method = "near" elif self.params['method'] == "linear": gdal_method = "bilinear" else: gdal_method = self.params['method'] # RGB rasters - alpha layer is added for cropping edges of projected raster try: if self.temp_map_bands_num == 3: ps = grass.Popen([ 'gdalwarp', '-s_srs', '%s' % self.proj_srs, '-t_srs', '%s' % self.proj_location, '-r', gdal_method, '-dstalpha', self.temp_map, self.temp_warpmap ], stdout=nuldev) # RGBA rasters else: ps = grass.Popen([ 'gdalwarp', '-s_srs', '%s' % self.proj_srs, '-t_srs', '%s' % self.proj_location, '-r', gdal_method, self.temp_map, self.temp_warpmap ], stdout=nuldev) ps.wait() except OSError as e: grass.fatal('%s \nThis can be caused by missing %s utility. ' % (e, 'gdalwarp')) if nuldev: nuldev.close() if ps.returncode != 0: grass.fatal(_('%s failed') % 'gdalwarp') grass.try_remove(self.temp_map) # raster projection is same as projection of location else: self.temp_warpmap = self.temp_map self.temp_files_to_cleanup.remove(self.temp_map) return self.temp_warpmap
def _initializeParameters(self, options, flags): self._debug("_initialize_parameters", "started") # initialization of module parameters (options, flags) self.params['driver'] = options['driver'] drv_info = WMSDriversInfo() driver_props = drv_info.GetDrvProperties(options['driver']) self._checkIgnoeredParams(options, flags, driver_props) self.params['capfile'] = options['capfile'].strip() for key in ['url', 'layers', 'styles', 'method']: self.params[key] = options[key].strip() self.flags = flags if self.flags['o']: self.params['transparent'] = 'FALSE' else: self.params['transparent'] = 'TRUE' for key in ['password', 'username', 'urlparams']: self.params[key] = options[key] if (self.params ['password'] and self.params ['username'] == '') or \ (self.params['password'] == '' and self.params['username']): grass.fatal( _("Please insert both %s and %s parameters or none of them." % ('password', 'username'))) self.params['bgcolor'] = options['bgcolor'].strip() if options['format'] == "jpeg" and \ not 'format' in driver_props['ignored_params']: if not flags['o'] and \ 'WMS' in self.params['driver']: grass.warning(_("JPEG format does not support transparency")) self.params['format'] = drv_info.GetFormat(options['format']) if not self.params['format']: self.params['format'] = self.params['format'] # TODO: get srs from Tile Service file in OnEarth_GRASS driver self.params['srs'] = int(options['srs']) if self.params['srs'] <= 0 and not 'srs' in driver_props[ 'ignored_params']: grass.fatal(_("Invalid EPSG code %d") % self.params['srs']) self.params['wms_version'] = options['wms_version'] if "CRS" in GetSRSParamVal( self.params['srs']) and self.params['wms_version'] == "1.1.1": self.params['wms_version'] = "1.3.0" grass.warning( _("WMS version <1.3.0> will be used, because version <1.1.1> does not support <%s>projection" ) % GetSRSParamVal(self.params['srs'])) if self.params['wms_version'] == "1.3.0": self.params['proj_name'] = "CRS" else: self.params['proj_name'] = "SRS" # read projection info self.proj_location = grass.read_command('g.proj', flags='jf').rstrip('\n') self.proj_location = self._modifyProj(self.proj_location) self.source_epsg = str(GetEpsg(self.params['srs'])) self.target_epsg = None target_crs = grass.parse_command('g.proj', flags='g', delimiter='=') if 'epsg' in target_crs.keys(): self.target_epsg = target_crs['epsg'] if self.source_epsg != self.target_epsg: grass.warning( _("SRS differences: WMS source EPSG %s != location EPSG %s (use srs=%s to adjust)" ) % (self.source_epsg, self.target_epsg, self.target_epsg)) self.proj_srs = grass.read_command('g.proj', flags='jf', epsg=str(GetEpsg( self.params['srs']))) self.proj_srs = self.proj_srs.rstrip('\n') self.proj_srs = self._modifyProj(self.proj_srs) if not self.proj_srs or not self.proj_location: grass.fatal(_("Unable to get projection info")) self.region = options['region'] min_tile_size = 100 maxcols = int(options['maxcols']) if maxcols <= min_tile_size: grass.fatal(_("Maxcols must be greater than 100")) maxrows = int(options['maxrows']) if maxrows <= min_tile_size: grass.fatal(_("Maxrows must be greater than 100")) # setting optimal tile size according to maxcols and maxrows constraint # and region cols and rows self.tile_size['cols'] = int( self.region['cols'] / ceil(self.region['cols'] / float(maxcols))) self.tile_size['rows'] = int( self.region['rows'] / ceil(self.region['rows'] / float(maxrows))) # default format for GDAL library self.gdal_drv_format = "GTiff" self._debug("_initialize_parameters", "finished")
def main(): global insert_sql insert_sql = None global temporary_vect temporary_vect = None global stats_temp_file stats_temp_file = None segment_map = options['map'] csvfile = options['csvfile'] if options['csvfile'] else [] vectormap = options['vectormap'] if options['vectormap'] else [] global rasters rasters = options['rasters'].split(',') if options['rasters'] else [] area_measures = options['area_measures'].split(',') if ( options['area_measures'] and not flags['s']) else [] if area_measures: if not gscript.find_program('r.object.geometry', '--help'): message = _( "You need to install the addon r.object.geometry to be able") message += _(" to calculate area measures.\n") message += _( " You can install the addon with 'g.extension r.object.geometry'" ) gscript.fatal(message) neighborhood = True if flags['n'] else False if neighborhood: if not gscript.find_program('r.neighborhoodmatrix', '--help'): message = _( "You need to install the addon r.neighborhoodmatrix to be able" ) message += _(" to calculate area measures.\n") message += _( " You can install the addon with 'g.extension r.neighborhoodmatrix'" ) gscript.fatal(message) raster_statistics = options['raster_statistics'].split( ',') if options['raster_statistics'] else [] separator = gscript.separator(options['separator']) processes = int(options['processes']) output_header = ['cat'] output_dict = collections.defaultdict(list) raster_stat_dict = { 'zone': 0, 'min': 4, 'third_quart': 16, 'max': 5, 'sum': 12, 'null_cells': 3, 'median': 15, 'label': 1, 'first_quart': 14, 'range': 6, 'mean_of_abs': 8, 'stddev': 9, 'non_null_cells': 2, 'coeff_var': 11, 'variance': 10, 'sum_abs': 13, 'perc_90': 17, 'mean': 7 } geometry_stat_dict = { 'cat': 0, 'area': 1, 'perimeter': 2, 'compact_square': 3, 'compact_circle': 4, 'fd': 5, 'xcoords': 6, 'ycoords': 7 } if flags['r']: gscript.use_temp_region() gscript.run_command('g.region', raster=segment_map) stats_temp_file = gscript.tempfile() if area_measures: gscript.message(_("Calculating geometry statistics...")) output_header += area_measures stat_indices = [geometry_stat_dict[x] for x in area_measures] gscript.run_command('r.object.geometry', input_=segment_map, output=stats_temp_file, overwrite=True, quiet=True) firstline = True with open(stats_temp_file, 'r') as fin: for line in fin: if firstline: firstline = False continue values = line.rstrip().split('|') output_dict[values[0]] = [values[x] for x in stat_indices] if rasters: if not flags['c']: gscript.message(_("Checking usability of raster maps...")) for raster in rasters: if not gscript.find_file(raster, element='cell')['name']: gscript.message(_("Cannot find raster '%s'" % raster)) gscript.message(_("Removing this raster from list.")) rasters.remove(raster) raster_info = gscript.parse_command('r.univar', flags='g', map_=raster, quiet=True) if len(raster_info) == 0 or int(raster_info['null_cells']) > 0: message = 'Raster %s contains null values.\n' % raster message += 'This can lead to errors in the calculations.\n' message += 'Check region settings and raster extent.\n' message += 'Possibly fill null values of raster.\n' message += 'Removing this raster from list.' gscript.warning(message) while raster in rasters: rasters.remove(raster) continue if len(rasters) > 0: gscript.message(_("Calculating statistics for raster maps...")) if len(rasters) < processes: processes = len(rasters) gscript.message( _("Only one process per raster. Reduced number of processes to %i." % processes)) stat_indices = [raster_stat_dict[x] for x in raster_statistics] pool = Pool(processes) func = partial(worker, segment_map, stats_temp_file) pool.map(func, rasters) pool.close() pool.join() for raster in rasters: rastername = raster.split('@')[0] rastername = rastername.replace('.', '_') temp_file = stats_temp_file + '.' + rastername output_header += [ rastername + "_" + x for x in raster_statistics ] firstline = True with open(temp_file, 'r') as fin: for line in fin: if firstline: firstline = False continue values = line.rstrip().split('|') output_dict[values[0]] = output_dict[values[0]] + [ values[x] for x in stat_indices ] # Calculating neighborhood statistics if requested if neighborhood: gscript.message(_("Calculating neighborhood statistics...")) # Add neighbordhood statistics to headers original_nb_values = len(output_header) - 1 new_headers = ['neighbors_count'] for i in range(1, len(output_header)): new_headers.append('%s_nbrmean' % output_header[i]) new_headers.append('%s_nbrstddev' % output_header[i]) output_header += new_headers # Get sorted neighborhood matrix nbr_matrix = sorted([ x.split('|') for x in gscript.read_command('r.neighborhoodmatrix', input_=segment_map, flags='d', quiet=True).splitlines() ]) # Calculate mean and stddev of neighbor values for each variable in the # output_dict for key, group in groupby(nbr_matrix, lambda x: x[0]): d = {} for i in range(original_nb_values): d[i] = (0, 0, 0) nbrlist = [str(x[1]) for x in group] if len(nbrlist) > 1: for nbr in nbrlist: for i in range(original_nb_values): d[i] = update(d[i], float(output_dict[nbr][i])) output_dict[key] = output_dict[key] + [str(len(nbrlist))] output_dict[key] = output_dict[key] + [ str(i) for sub in [finalize(x) for x in d.values()] for i in sub ] else: newvalues = ['1'] nbr = nbrlist[0] for i in range(original_nb_values): newvalues.append(output_dict[nbr][i]) newvalues.append('0') output_dict[key] = output_dict[key] + newvalues message = _("Some values could not be calculated for the objects below. ") message += _("These objects are thus not included in the results. ") message += _("HINT: Check some of the raster maps for null values ") message += _("and possibly fill these values with r.fillnulls.") error_objects = [] if csvfile: with open(csvfile, 'wb') as f: f.write(separator.join(output_header) + "\n") for key in output_dict: if len(output_dict[key]) + 1 == len(output_header): f.write(key + separator + separator.join(output_dict[key]) + "\n") else: error_objects.append(key) f.close() if vectormap: gscript.message(_("Creating output vector map...")) temporary_vect = 'segmstat_tmp_vect_%d' % os.getpid() gscript.run_command('r.to.vect', input_=segment_map, output=temporary_vect, type_='area', flags='vt', overwrite=True, quiet=True) insert_sql = gscript.tempfile() fsql = open(insert_sql, 'w') fsql.write('BEGIN TRANSACTION;\n') if gscript.db_table_exist(temporary_vect): if gscript.overwrite(): fsql.write('DROP TABLE %s;' % temporary_vect) else: gscript.fatal( _("Table %s already exists. Use --o to overwrite" % temporary_vect)) create_statement = 'CREATE TABLE ' + temporary_vect + ' (cat int PRIMARY KEY);\n' fsql.write(create_statement) for header in output_header[1:]: addcol_statement = 'ALTER TABLE %s ADD COLUMN %s double precision;\n' % ( temporary_vect, header) fsql.write(addcol_statement) for key in output_dict: if len(output_dict[key]) + 1 == len(output_header): sql = "INSERT INTO %s VALUES (%s, %s);\n" % ( temporary_vect, key, ",".join(output_dict[key])) sql = sql.replace('inf', 'NULL') sql = sql.replace('nan', 'NULL') fsql.write(sql) else: if not csvfile: error_objects.append(key) fsql.write('END TRANSACTION;') fsql.close() gscript.run_command('db.execute', input=insert_sql, quiet=True) gscript.run_command('v.db.connect', map_=temporary_vect, table=temporary_vect, quiet=True) gscript.run_command('g.copy', vector="%s,%s" % (temporary_vect, vectormap), quiet=True) if error_objects: object_string = ', '.join(error_objects[:100]) message += _( "\n\nObjects with errors (only first 100 are shown):\n%s" % object_string) gscript.message(message)
def raster_exists(envlay): """Check if the raster map exists, call GRASS fatal otherwise""" for chl in range(len(envlay)): ffile = gs.find_file(envlay[chl], element="cell") if not ffile["fullname"]: gs.fatal(_("The layer {} does not exist".format(envlay[chl])))