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 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 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 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 main(): """Sets the GRASS display driver .. todo:: use command line options as an alternative to wizard """ options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.settings import UserSettings from core.globalvar import CheckWxVersion from core.giface import StandaloneGrassInterface from gcp.manager import GCPWizard 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() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() wizard = GCPWizard(parent=None, giface=StandaloneGrassInterface()) app.MainLoop()
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 main(): """Sets the GRASS display driver """ 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' # TODO: message format should not be GUI # TODO: should messages here be translatable? # (for test its great, for translator not) options, flags = grass.parser() test = options['test'] app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() map_ = Map() if options['raster']: names = options['raster'] for name in names.split(','): cmdlist = ['d.rast', 'map=%s' % name] map_.AddLayer(ltype='raster', command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=True) if options['vector']: names = options['vector'] for name in names.split(','): cmdlist = ['d.vect', 'map=%s' % name] map_.AddLayer(ltype='vector', command=cmdlist, active=True, name=name, hidden=False, opacity=1.0, render=True) giface = MapdispGrassInterface(map_=map_) tester = Tester() if test == 'mapwindow': tester.testMapWindow(giface, map_) elif test == 'mapdisplay': tester.testMapDisplay(giface, map_) elif test == 'apitest': tester.testMapWindowApi(giface, map_) elif test == 'distance': tester.testMapWindowDistance(giface, map_) elif test == 'profile': tester.testMapWindowProfile(giface, map_) elif test == 'rlisetup': tester.testMapWindowRlisetup(map_) else: # TODO: this should not happen but happens import grass.script as sgrass sgrass.fatal(_("Unknown value %s of test parameter." % test)) app.MainLoop()
def main(): options, flags = gscript.parser() araster = options['araster'] braster = options['braster'] output = options['output'] gscript.mapcalc('{r} = {a} + {b}'.format(r=output, a=araster, b=braster)) return 0
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.utils import _ from core.giface import StandaloneGrassInterface try: from tplot.frame import TplotFrame except ImportError as e: gscript.fatal(e.message) rasters = None if options['strds']: rasters = options['strds'].strip().split(',') coords = None if options['coordinates']: coords = options['coordinates'].strip().split(',') cats = None if options['cats']: cats = options['cats'] output = options['output'] vectors = None attr = None if options['stvds']: vectors = options['stvds'].strip().split(',') if not options['attr']: gscript.fatal(_("With stvds you have to set 'attr' option")) else: attr = options['attr'] if coords and cats: gscript.fatal(_("With stvds it is not possible to use 'coordinates' " "and 'cats' options together")) elif not coords and not cats: gscript.warning(_("With stvds you have to use 'coordinates' or " "'cats' option")) app = wx.App() frame = TplotFrame(parent=None, giface=StandaloneGrassInterface()) frame.SetDatasets(rasters, vectors, coords, cats, attr) if output: frame.OnRedraw() if options['size']: sizes = options['size'].strip().split(',') sizes = [int(s) for s in sizes] frame.canvas.SetSize(sizes) if output.split('.')[-1].lower() == 'png': frame.canvas.print_png(output) if output.split('.')[-1].lower() in ['jpg', 'jpeg']: frame.canvas.print_jpg(output) if output.split('.')[-1].lower() in ['tif', 'tiff']: frame.canvas.print_tif(output) else: frame.Show() app.MainLoop()
def main(): gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.giface import StandaloneGrassInterface from core.globalvar import CheckWxVersion from rlisetup.frame import RLiSetupFrame app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = RLiSetupFrame(parent=None, giface=StandaloneGrassInterface()) frame.Show() frame.CenterOnScreen() app.MainLoop()
def main(): single_command = preparse_exec() options, flags = gscript.parser() script_path = options['grass_script'] # TODO: read script from stdin # TODO: support creating grassdata in a tmp place remote_grassdata = options['grassdata'] remote_location = options['location'] remote_mapset = options['mapset'] raster_inputs = as_list(options['raster_input']) raster_outputs = as_list(options['raster_output']) vector_inputs = as_list(options['vector_input']) vector_outputs = as_list(options['vector_output']) grass_version = version_to_number(options['grass_version']) session = get_session(options) # TODO: use variable, e.g. for packing if options['local_workdir']: local_workdir = options['local_workdir'] else: # TODO: this should be tmp local_workdir = '.' from grasssession import GrassSession # TODO: default grass binary should be derived from the version we are running gsession = GrassSession(connection=session, grassdata=remote_grassdata, location=remote_location, mapset=remote_mapset, grass_command=options['grass_command'], grass_version=grass_version, directory=options['remote_workdir']) if flags['l']: gsession.create_location() gsession.put_region() gsession.put_rasters(raster_inputs) gsession.put_vectors(vector_inputs) if script_path: gsession.run_script(script_path) elif single_command: gsession.run_bash_command(single_command) # TODO: add also Python code as an input gsession.get_rasters(raster_outputs) gsession.get_vectors(vector_outputs) gsession.close()
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.settings import UserSettings from core.globalvar import CheckWxVersion from core.giface import StandaloneGrassInterface from core.utils import _ from mapswipe.frame import SwipeMapFrame 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 = gscript.find_file(name=mapName) if not gfile['name']: gscript.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, flags = gscript.parser() # import wx only after running parser # to avoid issues when only interface is needed import wx from grass.script.setup import set_gui_path set_gui_path() from core.giface import StandaloneGrassInterface from datacatalog.frame import DataCatalogFrame app = wx.App() frame = DataCatalogFrame(parent=None, giface=StandaloneGrassInterface()) frame.CentreOnScreen() frame.Show() app.MainLoop()
def main(): options, flags = gs.parser() # main options map_name = options['input'] output_file = options['output'] # TODO: other options of g.proj are not supported epsg_code = int(options['epsg']) # r.out.png options compression = int(options['compression']) # both flags (tw) passed to r.out.png routpng_flags = '' if flags['t']: routpng_flags += 't' if flags['w']: routpng_flags += 'w' if flags['l']: wgs84_file = output_file + '.wgs84' else: wgs84_file = None if flags['m']: use_region = False else: use_region = True # TODO: mixing current and map's mapset at this point # or perhaps not an issue if parser adds mapset automatically (?) if '@' in map_name: map_name, src_mapset_name = map_name.split('@') else: src_mapset_name = gs.gisenv()['MAPSET'] export_png_in_projection(map_name=map_name, src_mapset_name=src_mapset_name, output_file=output_file, epsg_code=epsg_code, compression=compression, routpng_flags=routpng_flags, wgs84_file=wgs84_file, use_region=use_region)
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.giface import StandaloneGrassInterface from core.globalvar import CheckWxVersion from gmodeler.frame import ModelFrame app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = ModelFrame(parent=None, giface=StandaloneGrassInterface()) if options['file']: frame.LoadModelFile(options['file']) frame.Show() app.MainLoop()
def main(): options, flags = gscript.parser() import wx from grass.script.setup import set_gui_path set_gui_path() from core.globalvar import CheckWxVersion from psmap.frame import PsMapFrame app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = PsMapFrame(parent=None) frame.Show() if options['file']: frame.LoadFile(options['file']) app.MainLoop()
def loadDefs(): if '--ui' in sys.argv: sys.argv.remove('--ui') # get names of module parameters options, flags = grass.parser() # get default values for the arguments defoptions = p.__dict__ defoptions.update(p.readPar()) defflags = [] switches = dict(zip(components.values(),components.keys())) # update options for a in defoptions: # parameter in header and not already set if a in options and options[a]=='': options[a] = defoptions[a] # check flags if a in switches and (defoptions[a] != 0 or (a in flags and flags[a])): defflags += [switches[a]] # recreate commandline arguments sys.argv += ['-%s' %''.join(defflags)] sys.argv += ['%s=%s' %s for s in options.items()] sys.argv += ['--ui'] return
def main(): options, flags = grass.parser() satellite = options['sensor'] output_basename = options['output'] inputs = options['input'].split(',') num_of_bands = used_bands[satellites.index(satellite)] if len(inputs) != num_of_bands: grass.fatal(_("The number of input raster maps (bands) should be %s") % num_of_bands) bands = {} for i, band in enumerate(inputs): band_num = i + 1 bands['in' + str(band_num) + 'band'] = band grass.debug(1, bands) # core tasseled cap components computation calcN(output_basename, bands, satellite) # assign "Data Description" field in all four component maps for i, comp in enumerate(names): grass.run_command('r.support', map="%s.%d" % (output_basename, i + 1), description="Tasseled Cap %d: %s" % (i + 1, comp)) grass.message(_("Tasseled Cap components calculated"))
else: end = start_time + int(gran) granule.set_relative_time(start, end, sp.get_relative_time_unit()) start_time = end granularity_list.append(granule) output_list = tgis.aggregate_by_topology(granularity_list=granularity_list, granularity=gran, map_list=map_list, topo_list=topo_list, basename=base, time_suffix=time_suffix, offset=offset, method=method, nprocs=nprocs, spatial=None, overwrite=gcore.overwrite()) if output_list: temporal_type, semantic_type, title, description = sp.get_initial_values() output_strds = tgis.open_new_stds(output, "strds", temporal_type, title, description, semantic_type, dbif, gcore.overwrite()) tgis.register_map_object_list("rast", output_list, output_strds, register_null, sp.get_relative_time_unit(), dbif) # Update the raster metadata table entries with aggregation type output_strds.set_aggregation_type(method) output_strds.metadata.update(dbif) dbif.close() if __name__ == "__main__": options, flags = gcore.parser() main()
if dtypes[c] in [float, int]: dtypes[c] = float tbl[c][i] = 'nan' # actual type conversion convertedvals += [np.array(tbl[c], dtype=dtypes[c])] # now properly make it tbl = np.array(zip(*convertedvals), dtype=[(c, dtypes[c]) for c in cols]) tbl.sort() return tbl if __name__ == '__main__': # start time st = dt.datetime.now() # get options and flags o, f = grass.parser() fmt = lambda d: '\n'.join(['%s: %s' % (k, v) for k, v in d.items()])+'\n' grass.message('GIS Environment:\n'+fmt(grass.gisenv())) grass.message('Parameters:\n'+fmt(o)+fmt(f)) # warn if MASKED if 'MASK' in grass.list_grouped('rast')[grass.gisenv()['MAPSET']]: maskcells = gread('r.stats', input='MASK', flags='nc').split()[1] grass.message('!!! MASK active with %s cells, will only process those !!!' % maskcells) # send all to main keywords = o keywords.update(f) main = main(**keywords)
def main(): options, flags = gscript.parser() # import wx only after running parser # to avoid issues when only interface is needed import grass.temporal as tgis import wx from grass.script.setup import set_gui_path set_gui_path() from core.globalvar import CheckWxVersion from core.utils import _ from core.giface import StandaloneGrassInterface from core.layerlist import LayerList from animation.frame import AnimationFrame, MAX_COUNT from animation.data import AnimLayer rast = options['raster'] vect = options['vector'] strds = options['strds'] stvds = options['stvds'] numInputs = 0 if rast: numInputs += 1 if vect: numInputs += 1 if strds: numInputs += 1 if stvds: numInputs += 1 if numInputs > 1: gscript.fatal( _("%s=, %s=, %s= and %s= are mutually exclusive.") % ("raster", "vector", "strds", "stvds")) if numInputs > 0: # We need to initialize the temporal framework in case # a space time dataset was set on the command line so that # the AnimLayer() class works correctly tgis.init() layerList = LayerList() if rast: layer = AnimLayer() layer.mapType = 'raster' layer.name = rast layer.cmd = ['d.rast', 'map={name}'.format(name=rast.split(',')[0])] layerList.AddLayer(layer) if vect: layer = AnimLayer() layer.mapType = 'vector' layer.name = vect layer.cmd = ['d.vect', 'map={name=}'.format(name=vect.split(',')[0])] layerList.AddLayer(layer) if strds: layer = AnimLayer() layer.mapType = 'strds' layer.name = strds layer.cmd = ['d.rast', 'map='] layerList.AddLayer(layer) if stvds: layer = AnimLayer() layer.mapType = 'stvds' layer.name = stvds layer.cmd = ['d.vect', 'map='] layerList.AddLayer(layer) app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = AnimationFrame(parent=None, giface=StandaloneGrassInterface()) frame.CentreOnScreen() frame.Show() if len(layerList) >= 1: # CallAfter added since it was crashing with wxPython 3 gtk wx.CallAfter(frame.SetAnimations, [layerList] + [None] * (MAX_COUNT - 1)) app.MainLoop()
# Write layer metadata gs.run_command("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: gs.run_command("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")) if __name__ == "__main__": atexit.register(cleanup) sys.exit(main(*gs.parser()))
def main(): options, flags = grass.parser() xAmap = options['xaraster'] xBmap = options['xbraster'] yAmap = options['yaraster'] yBmap = options['ybraster'] output_basename = options['output'] custom_threshold = options['custom_threshold'] stat_threshold = options['stat_threshold'] Xdelta_name = 'deltaX' Ydelta_name = 'deltaY' anglemap_name = output_basename + '_angle' anglemap_class = anglemap_name + '_class' magnitudemap_name = output_basename + '_magnitude' changemap_name = output_basename + '_change' # Checking that the input maps exist if not grass.find_file(name=xAmap, element='cell')['file']: grass.fatal("xaraster map <%s> not found" % xAmap) if not grass.find_file(name=xBmap, element='cell')['file']: grass.fatal("xbraster map <%s> not found" % xBmap) if not grass.find_file(name=yAmap, element='cell')['file']: grass.fatal("yaraster map <%s> not found" % yAmap) if not grass.find_file(name=xBmap, element='cell')['file']: grass.fatal("ybraster map <%s> not found" % yBmap) TMPRAST.append(Xdelta_name) TMPRAST.append(Ydelta_name) # Calculating delta for X and Y bands grass.message(_("Calculating DeltaX and DeltaY")) delta_calculation(Xdelta_name, xBmap, xAmap) delta_calculation(Ydelta_name, yBmap, yAmap) #Calculating angle and magnitude maps grass.message(_("Writing angle map %s") % anglemap_name) angle_calculation(anglemap_name, Xdelta_name, Ydelta_name) grass.message(_("Writing magnitude map %s") % magnitudemap_name) magnitude_calculation(magnitudemap_name, Xdelta_name, Ydelta_name) # Reclassifing angle map to get a map with the four quadrants keys = ['1', '2', '3', '4'] vals = [0, 90, 180, 270, 360] rvals = [(int(vals[i-1]), int(vals[i]), keys[i-1], vals[i-1], vals[i]) for i in range(1, len(vals))] rules = '\n'.join(['%3d thru %3d = %s %s-%s' % v for v in rvals]) script.write_command('r.reclass', input=anglemap_name, output=anglemap_class, rules='-', overwrite=True, stdin=rules.encode()) # Generating the change detection map using the given threshold if custom_threshold: threshold = custom_threshold grass.message(_("Threshold is %s") % threshold) grass.message(_("Writing change detection map %s") % changemap_name) # Creating the final map of the change, using a custom threshold change_map_calculation(changemap_name, magnitudemap_name, threshold, anglemap_class) elif stat_threshold: #Getting values of mean and standard dev of magnitude to calculate the change detection criteria (> mean + N*stdev) univar = grass.read_command('r.univar', map=magnitudemap_name, flags='g') found = 0 for line in univar.splitlines(): name,val = line.split('=') if name == 'mean': grass.message(_("Mean of magnitude values is: %s") % val) mean = val found += 1 if name == 'stddev': grass.message(_("Standard deviation of magnitude values is: %s") % val) stddev = val found += 1 if found != 2: grass.fatal("Couldn\'t find mean or stddev!") adding_value = float(stat_threshold) * float(stddev) threshold = float(mean) + float(adding_value) grass.message(_("Threshold is %s") % threshold) #Creating the final map of the change, using a statistical threshold change_map_calculation(changemap_name, magnitudemap_name, threshold, anglemap_class) else: grass.message(_("No threshold given, only angle and magnitude maps have been created")) return 0
name=outname) grass.run_command('r.reclass', input=i, out=outname, rules=outfile.name) elif result['fullname'] and not grass.overwrite(): grass.warning( _("Raster map %s already exists and will not be overwritten" % i)) else: grass.run_command('r.reclass', input=i, out=outname, rules=outfile.name) output_names.append(outname) # remove the rules file grass.try_remove(outfile.name) # write cmd history: grass.raster_history(outname) db.commit() db.close() if mosaic: grass.message(_("Processing mosaic <%s>..." % mosaic)) grass.run_command('g.region', raster=all_images) grass.run_command('r.patch', input=output_names, output=mosaic) if __name__ == "__main__": options, flags = grass.parser() sys.exit(main())
def main(): options, flags = gs.parser() # it does not check if pngs and other files exists, # maybe it could check the any/all file(s) dir if options['raster'] and options['strds']: gs.fatal(_("Options raster and strds cannot be specified together." " Please decide for one of them.")) if options['raster'] and options['where']: gs.fatal(_("Option where cannot be combined with the option raster." " Please don't set where option or use strds option" " instead of raster option.")) if options['raster']: if ',' in options['raster']: maps = options['raster'].split(',') # TODO: skip empty parts else: maps = [options['raster']] elif options['strds']: # import and init only when needed # init is called anyway when the generated form is used import grass.temporal as tgis strds = options['strds'] where = options['where'] # make sure the temporal database exists tgis.init() # create the space time raster object ds = tgis.open_old_space_time_dataset(strds, 'strds') # check if the dataset is in the temporal database if not ds.is_in_db(): gs.fatal(_("Space time dataset <%s> not found") % strds) # we need a database interface dbiface = tgis.SQLDatabaseInterfaceConnection() dbiface.connect() # the query rows = ds.get_registered_maps(columns='id', where=where, order='start_time') if not rows: gs.fatal(_("Cannot get any maps for spatio-temporal raster" " dataset <%s>." " Dataset is empty or you temporal WHERE" " condition filtered all maps out." " Please, specify another dataset," " put maps into this dataset" " or correct your WHERE condition.") % strds) maps = [row['id'] for row in rows] else: gs.fatal(_("Either raster or strds option must be specified." " Please specify one of them.")) # get the number of maps for later use num_maps = len(maps) out_dir = options['output'] if not os.path.exists(out_dir): # TODO: maybe we could create the last dir on specified path? gs.fatal(_("Output path <%s> does not exists." " You need to create the (empty) output directory" " yourself before running this module.") % out_dir) epsg = int(options['epsg']) if ',' in options['opacity']: opacities = [float(opacity) for opacity in options['opacity'].split(',')] if len(opacities) != num_maps: gs.fatal(_("Number of opacities <{no}> does not match number" " of maps <{nm}>.").format(no=len(opacities), nm=num_maps)) else: opacities = [float(options['opacity'])] * num_maps if ',' in options['info']: infos = options['info'].split(',') else: infos = [options['info']] if 'geotiff' in infos and not gs.find_program('r.out.tiff', '--help'): gs.fatal(_("Install r.out.tiff add-on module to export GeoTIFF")) # r.out.png options compression = int(options['compression']) # flag w is passed to r.out.png.proj # our flag n is inversion of r.out.png.proj's t flag # (transparent NULLs are better for overlay) # we always need the l flag (ll .wgs84 file) routpng_flags = '' if not flags['n']: routpng_flags += 't' if flags['w']: routpng_flags += 'w' # r.out.png.proj l flag for LL .wgs84 file is now function parameter # and is specified bellow if flags['m']: use_region = False # we will use map extent gs.use_temp_region() else: use_region = True # hard coded file names data_file_name = 'data_file.csv' js_data_file_name = 'data_file.js' data_file = open(os.path.join(out_dir, data_file_name), 'w') js_data_file = open(os.path.join(out_dir, js_data_file_name), 'w') js_data_file.write('/* This file was generated by r.out.leaflet GRASS GIS' ' module. */\n\n') js_data_file.write('var layerInfos = [\n') for i, map_name in enumerate(maps): if not use_region: gs.run_command('g.region', rast=map_name) if '@' in map_name: pure_map_name = map_name.split('@')[0] else: pure_map_name = map_name # TODO: mixing current and map's mapset at this point if '@' in map_name: map_name, src_mapset_name = map_name.split('@') else: # TODO: maybe mapset is mandatory for those out of current mapset? src_mapset_name = gs.gisenv()['MAPSET'] image_file_name = pure_map_name + '.png' image_file_path = os.path.join(out_dir, image_file_name) # TODO: skip writing to file and extract the information from # function, or use object if function is so large wgs84_file = image_file_path + '.wgs84' export_png_in_projection(map_name=map_name, src_mapset_name=src_mapset_name, output_file=image_file_path, epsg_code=epsg, compression=compression, routpng_flags=routpng_flags, wgs84_file=wgs84_file, use_region=True) data_file.write(pure_map_name + ',' + image_file_name + '\n') # it doesn't matter in which location we are, it just uses the current # location, not tested for LL loc, assuming that to be nop. map_extent = get_map_extent_for_file(wgs84_file) bounds = map_extent_to_js_leaflet_list(map_extent) extra_attributes = [] generate_infos(map_name=map_name, projected_png_file=image_file_path, required_infos=infos, output_directory=out_dir, attributes=extra_attributes) # http://www.w3schools.com/js/js_objects.asp js_data_file.write(""" {{title: "{title}", file: "{file_}",""" """ bounds: {bounds}, opacity: {opacity}""" .format(title=pure_map_name, file_=image_file_name, bounds=bounds, opacity=opacities[i])) if extra_attributes: extra_js_attributes = [pair[0] + ': "' + escape_quotes( escape_endlines( escape_backslashes( pair[1] ))) + '"' for pair in extra_attributes] js_data_file.write(', ' + ', '.join(extra_js_attributes)) js_data_file.write("""}\n""") # do not write after the last item if i < num_maps - 1: js_data_file.write(',') js_data_file.write('];\n') data_file.close()
# 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) if __name__ == '__main__': if len(sys.argv) > 1: sys.exit(main(argv=grass.parser())) else: main()
def main(): options, flags = gscript.parser() # import wx only after running parser # to avoid issues when only interface is needed import grass.temporal as tgis import wx from grass.script.setup import set_gui_path set_gui_path() from core.globalvar import CheckWxVersion from core.utils import _ from core.giface import StandaloneGrassInterface from core.layerlist import LayerList from animation.frame import AnimationFrame, MAX_COUNT from animation.data import AnimLayer rast = options['raster'] vect = options['vector'] strds = options['strds'] stvds = options['stvds'] numInputs = 0 if rast: numInputs += 1 if vect: numInputs += 1 if strds: numInputs += 1 if stvds: numInputs += 1 if numInputs > 1: gscript.fatal(_("%s=, %s=, %s= and %s= are mutually exclusive.") % ("raster", "vector", "strds", "stvds")) if numInputs > 0: # We need to initialize the temporal framework in case # a space time dataset was set on the command line so that # the AnimLayer() class works correctly tgis.init() layerList = LayerList() if rast: layer = AnimLayer() layer.mapType = 'raster' layer.name = rast layer.cmd = ['d.rast', 'map={name}'.format(name=rast.split(',')[0])] layerList.AddLayer(layer) if vect: layer = AnimLayer() layer.mapType = 'vector' layer.name = vect layer.cmd = ['d.vect', 'map={name}'.format(name=vect.split(',')[0])] layerList.AddLayer(layer) if strds: layer = AnimLayer() layer.mapType = 'strds' layer.name = strds layer.cmd = ['d.rast', 'map='] layerList.AddLayer(layer) if stvds: layer = AnimLayer() layer.mapType = 'stvds' layer.name = stvds layer.cmd = ['d.vect', 'map='] layerList.AddLayer(layer) app = wx.App() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = AnimationFrame(parent=None, giface=StandaloneGrassInterface()) frame.CentreOnScreen() frame.Show() if len(layerList) >= 1: # CallAfter added since it was crashing with wxPython 3 gtk wx.CallAfter(frame.SetAnimations, [layerList] + [None] * (MAX_COUNT - 1)) app.MainLoop()
'end': options['end'], 'sortby': sortby, 'asc': True if options['order'] == 'asc' else False, 'relativeorbitnumber': options['relativeorbitnumber'] } if options['datasource'] == 'ESA_COAH': downloader.filter(**filter_args) elif options['datasource'] == 'USGS_EE': downloader.filter_USGS(**filter_args) except Exception as e: gs.fatal( _('Unable to connect to {0}: {1}').format(options['datasource'], e)) if options['footprints']: downloader.save_footprints(options['footprints']) if flags['l']: downloader.list() return downloader.download(options['output'], options['sleep'], int(options['retry'])) return 0 if __name__ == "__main__": options, flags = gs.parser() sys.exit(main())
offset = 0 offsets = [] parms = {} for n, img in enumerate(images): offsets.append(offset) parms['image%d' % (n + 1)] = img parms['offset%d' % (n + 1)] = offset offset += get_limit(img) + 1 gscript.message(_("Mosaicing %d images...") % count) gscript.mapcalc("$output = " + make_expression(1, count), output=output, **parms) # modify the color table: p = gscript.feed_command('r.colors', map=output, rules='-') for img, offset in zip(images, offsets): print(img, offset) copy_colors(p.stdin, img, offset) p.stdin.close() p.wait() gscript.message(_("Done. Raster map <%s> created.") % output) # write cmd history: gscript.raster_history(output) if __name__ == "__main__": options, flags = gscript.parser() main()
alayer = "1", atype = "auto", binput = "fp_65r_42@report", blayer = "1", btype = "area", operator = "or", output = "fp_pad42", olayer = "1,0,0", snap = 1e-8) run_command("v.db.addcolumn", map = "fp_pad42", layer = "1", columns = "subarea double precision") run_command("v.to.db", map = "fp_pad42", layer = "1", type = "point,line,boundary,centroid", option = "area", columns = "subarea", query_layer = "1", separator = "pipe") return 0 if __name__ == "__main__": options, flags = parser() atexit.register(cleanup) sys.exit(main())
Module('g.region', res=resolution, vector=['startp', 'endp']) Module('g.region', n='n+{}'.format(offset), s='s-{}'.format(offset), e='e+{}'.format(offset), w='w-{}'.format(offset)) Module('r.cost', flags='k', input='rychlost_cas', output='rychlost_naklady', start_points='startp', overwrite=True) Module('r.drain', flags='n', input='rychlost_naklady', output=option['output'], start_points='endp') Module('r.to.vect', flags='s', input=option['output'], output=option['output'], type='line') if __name__ == "__main__": option, flag = gscript.parser() main()
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.globalvar import CheckWxVersion from core.utils import _ 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() if not CheckWxVersion([2, 9]): wx.InitAllImageHandlers() frame = VDigitMapFrame(options['map']) frame.Show() app.MainLoop()
## Calculate final map statistics l_osm_proc = length(out) diff_osm = l_osm - l_osm_proc diff_p_osm = diff_osm/l_osm*100 diff_new = l_ref - l_osm_proc diff_p_new = diff_new/l_ref*100 ## Write output file with statistics (if required) if len(out_file)>0: fil=open(out_file,"w") fil.write("REF dataset length: %s m\n"%(round(l_ref,1))) fil.write("Original OSM dataset length: %s m\n"%(round(l_osm,1))) fil.write("Processed OSM dataset length: %s m\n"%(round(l_osm_proc,1))) fil.write("Difference between OSM original and processed datasets length: %s m (%s%%)\n"%(round(diff_osm,1),round(diff_p_osm,1))) fil.write("Difference between REF dataset and processed OSM dataset length: %s m (%s%%)\n"%(round(diff_new,1),round(diff_p_new,1))) fil.close() ## Print statistics print("#####################################################################\n") print("Original OSM dataset length: %s m\n"%(round(l_osm,1))) print("Processed OSM dataset length: %s m\n"%(round(l_osm_proc,1))) print("Difference between OSM original and processed datasets length: %s m (%s%%)\n"%(round(diff_osm,1),round(diff_p_osm,1))) print("Difference between REF dataset and processed OSM dataset length: %s m (%s%%)\n"%(round(diff_new,1),round(diff_p_new,1))) print("#####################################################################\n") if __name__ == "__main__": options,flags = grass.parser() sys.exit(main())
gs.fatal(_("Output map <%s> already exists") % output) # set aside region for internal use gs.use_temp_region() # subset input if desired region = options.get('region') if region: if not gs.find_file(region)['file']: gs.fatal(_("Raster map <%s> not found") % region) gs.message("Setting region to %s" % region, flag='i') gs.run_command('g.region', rast=region, align=input) else: gs.message("Using existing GRASS region", flag='i') gs.debug('='*50) gs.debug('\n'.join(gs.parse_command('g.region', 'p').keys())) gs.debug('='*50) calculate_noise(input, output) # restore original region gs.del_temp_region() return None if __name__ == '__main__': options, flags = gs.parser() atexit.register(cleanup) main()
self.process.wait() self.process = None if self.observer: try: self.observer.stop() except TypeError: # throws error on mac pass self.observer.join() self.timer.Stop() self.status.SetLabel("Real-time scanning stopped.") def runImport(self): run_analyses(scan_params=self.scan, analysesFile=self.settings['tangible']['analyses']['file']) evt = updateGUIEvt(self.GetId()) wx.PostEvent(self, evt) def main(giface=None): global Observer, RasterChangeHandler from watchdog.observers import Observer from change_handler import RasterChangeHandler dlg = TangibleLandscapePlugin(giface, parent=None) dlg.Show() if __name__ == '__main__': gscript.parser() from watchdog.observers import Observer from change_handler import RasterChangeHandler main()
def main(): """ Build gravity reservoirs in GSFLOW: combines MODFLOW grid and HRU sub-basins These define the PRMS soil zone that connects to MODFLOW cells """ ################## # OPTION PARSING # ################## # I/O options, flags = gscript.parser() # I/O HRUs = options['hru_input'] grid = options['grid_input'] segments = options['output'] #col = options['col'] gravity_reservoirs = options['output'] ############ # ANALYSIS # ############ """ # Basin areas v.db_addcolumn(map=basins, columns=col) v.to_db(map=basins, option='area', units='meters', columns=col) """ # Create gravity reservoirs -- overlay cells=grid and HRUs v.overlay(ainput=HRUs, binput=grid, atype='area', btype='area', operator='and', output=gravity_reservoirs, overwrite=gscript.overwrite()) v.db_dropcolumn(map=gravity_reservoirs, columns='a_cat,a_label,b_cat', quiet=True) # Cell and HRU ID's v.db_renamecolumn(map=gravity_reservoirs, column=('a_id', 'gvr_hru_id'), quiet=True) v.db_renamecolumn(map=gravity_reservoirs, column=('b_id', 'gvr_cell_id'), quiet=True) # Percent areas v.db_renamecolumn(map=gravity_reservoirs, column=('a_hru_area_m2', 'hru_area_m2'), quiet=True) v.db_renamecolumn(map=gravity_reservoirs, column=('b_area_m2', 'cell_area_m2'), quiet=True) v.db_addcolumn(map=gravity_reservoirs, columns='area_m2 double precision', quiet=True) v.to_db(map=gravity_reservoirs, option='area', units='meters', columns='area_m2', quiet=True) v.db_addcolumn( map=gravity_reservoirs, columns='gvr_cell_pct double precision, gvr_hru_pct double precision', quiet=True) v.db_update(map=gravity_reservoirs, column='gvr_cell_pct', query_column='100*area_m2/cell_area_m2', quiet=True) v.db_update(map=gravity_reservoirs, column='gvr_hru_pct', query_column='100*area_m2/hru_area_m2', quiet=True) v.extract(input=gravity_reservoirs, output='tmp_', where="gvr_cell_pct > 0.001", overwrite=True, quiet=True) g.rename(vector=('tmp_', gravity_reservoirs), overwrite=True, quiet=True)