def collectresults(task,proc): for i in task: #print(i) #print(proc) #print("combining outputs for point " + str(i) + " and for cpu " + str(proc)) message = "Combining outputs for point %s and for cpu %s " gscript.message(message % (str(i),str(proc))) #updating the output layer of the angle #updating the output layer of the best angle of view among all the points in the path Module("r.mapcalc", expression="{A} = if(isnull({I}) ||| {I}==0,{A},max({A},{I}))".format(A='xxtemp_a_'+str(proc),I='zzangle'+i), overwrite=True, quiet=True) #updating the output layer of the category of the point who has the higher angles with the considered cell Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}<{Z},{A},{cat}))".format(A='xxtemp_c_'+str(proc),I='zzangle'+i,Z='xxtemp_a_'+str(proc),cat=i), overwrite=True, quiet=True) Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}<{Z},{A},{I}))".format(A='xxmaxangle_'+str(proc),I='zzangle'+i,Z='xxtemp_a_'+str(proc)), overwrite=True, quiet=True) #updating the output layer of the 3d distance #Module("r.mapcalc", expression="{A} = if(isnull({I}),{A}, min({I},{A}))".format(A='xxtemp_e_'+str(proc),I='distance'+i),overwrite=True, quiet=True) Module("r.mapcalc", expression="{A} = if(isnull({I}),{A}, if({A} != 0,min({I},{A}),{I}))".format(A='xxtemp_e_'+str(proc),I='zzdistance'+i),overwrite=True, quiet=True) #updating the output layer of the category of the point who has the higher solid angles with the considered cell Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}>{Z},{A},{cat}))".format(A='xxtemp_h_'+str(proc),I='zzdistance'+i,Z='xxtemp_e_'+str(proc),cat=i), overwrite=True, quiet=True) Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}>{Z},{A},{I}))".format(A='xxmin3ddistance_'+str(proc),I='zzdistance'+i,Z='xxtemp_e_'+str(proc)), overwrite=True, quiet=True) #updating the output layer of the solid angle #updating the output layer of the best solid angle of view among all the points in the path Module("r.mapcalc", expression="{A} = if(isnull({I}) ||| {I}==0,{A},max({A},{I}))".format(A='xxtemp_f_'+str(proc),I='zzsangle'+i), overwrite=True, quiet=True) #updating the output layer of the category of the point who has the higher solid angles with the considered cell Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}<{Z},{A},{cat}))".format(A='xxtemp_g_'+str(proc),I='zzsangle'+i,Z='xxtemp_f_'+str(proc),cat=i), overwrite=True, quiet=True) Module("r.mapcalc", expression="{A} = if({I}==0 ||| isnull({I}),{A}, if({I}<{Z},{A},{I}))".format(A='xxmaxsangle_'+str(proc),I='zzsangle'+i,Z='xxtemp_f_'+str(proc)), overwrite=True, quiet=True) #updating the output layer of the number of points a pixel is visible from #updating the output layer of the number of points from which a cell is visible Module("r.mapcalc", expression="{A} = if(isnull({I}) ||| {I}==0,{A},{A}+1)".format(A='xxtemp_b_'+str(proc),I='zzangle'+i), overwrite=True, quiet=True)
def getEPSG(self): proj=Module('g.proj', flags='p', quiet=True, stdout_=PIPE) proj=proj.outputs.stdout lines=proj.splitlines() for e,line in enumerate(lines): if 'EPSG' in line: epsg=lines[e+1].split(':')[1].replace(' ','') return epsg proj=Module('g.proj', flags='wf', quiet=True, stdout_=PIPE) proj=proj.outputs.stdout epsg = self.wkt2standards(proj) if not epsg: return None else: return epsg
def parseVect(self): '''Read metadata from v.info @var self.md_grass dictionary of metadata from v.info ''' # parse md from v.info flags=-g -e -t vinfo = Module('v.info', self.map, flags='get', quiet=True, stdout_=PIPE) self.md_grass = parse_key_val(vinfo.outputs.stdout) # parse md from v.info flag=h (history of map in grass) rinfo_h = Module('v.info', self.map, flags='h', quiet=True, stdout_=PIPE) md_h_grass = rinfo_h.outputs.stdout buf = io.StringIO(md_h_grass) line = buf.readline().splitlines() while str(line) != '[]': if str(line[0]).strip() != "": self.md_vinfo_h += line[0] + '\n' line = buf.readline().splitlines() buf.close() # convert GRASS parsed date format to iso format # if date format is diverse from standard, use them self._createISODate('source_date')
def parseTemporal(self): env = grass.gisenv() mapset = env['MAPSET'] if self.map.find("@") < 0: self.map = "{}@{}".format(self.map, mapset) tinfo = Module('t.info', self.map, flags='g', type=self.type, stdout_=PIPE) self.md_grass = parse_key_val(tinfo.outputs.stdout) tinfoHist = Module('t.info', input=self.map, quiet=True, flags='h', type=self.type, stdout_=PIPE) md_h_grass = tinfoHist.outputs.stdout buf = io.StringIO(md_h_grass) line = buf.readline().splitlines() while line: if str(line[0]).strip() != "": self.md_vinfo_h += line[0] + '\n' line = buf.readline().splitlines() buf.close()
def test_resolutions(self): """Test that resolution tests runs without nprocs and plots to file""" benchmarks = [ dict( module=Module("r.univar", map="elevation", stdout_=DEVNULL, run_=False), label="Standard output", ), dict( module=Module("r.univar", map="elevation", flags="g", stdout_=DEVNULL, run_=False), label="Standard output", ), ] resolutions = [300, 200, 100] results = [] for benchmark in benchmarks: results.append( benchmark_resolutions( **benchmark, resolutions=resolutions, )) plot_file = "test_res_plot.png" num_cells_plot(results, filename=plot_file) self.assertTrue(Path(plot_file).is_file())
def main(): check_date(options['start']) check_date(options['end']) # be silent os.environ['GRASS_VERBOSE'] = '0' try: Module('t.rast.series', input=options['input'], output=output, method='average', where="start_time > '{start}' and start_time < '{end}'".format( start=options['start'], end=options['end'] )) except CalledModuleError: gs.fatal('Unable to compute statistics') ret = Module('r.univar', flags='g', map=output, stdout_=PIPE ) stats = gs.parse_key_val(ret.outputs.stdout) print('Min: {0:.1f}'.format(float(stats['min']))) print('Max: {0:.1f}'.format(float(stats['max']))) print('Mean: {0:.1f}'.format(float(stats['mean'])))
def grassEpsg(): proj=Module('g.proj', flags='p', quiet=True, stdout_=PIPE) proj=proj.outputs.stdout lines=proj.splitlines() for e,line in enumerate(lines): if 'EPSG' in line: epsg=lines[e+1].split(':')[1].replace(' ','') print('epsg=%s' % epsg) if flags['s']: if isPermanent(): writeEPSGtoPEMANENT(epsg) else: grass.warning("Unable to access PERMANENT mapset") return try: proj=Module('g.proj', flags='wf', quiet=True, stdout_=PIPE) proj=proj.outputs.stdout wkt2standards(proj) except: grass.error('WKT input error')
def stats(): print('-' * 80) print('NDVI class statistics') print('-' * 80) from subprocess import PIPE ret = Module('v.report', map=options["output"], option='area', stdout_=PIPE) for line in ret.outputs.stdout.splitlines( )[1:]: # skip first line (cat|label|area) # parse line (eg. 1||2712850) data = line.split('|') cat = data[0] area = float(data[-1]) print('NDVI class {0}: {1:.1f} ha'.format(cat, area / 1e4)) # v.to.rast: use -c flag for updating statistics if exists Module('v.rast.stats', flags='c', map=options["output"], raster='ndvi', column_prefix='ndvi', method=['minimum', 'maximum', 'average']) data = vector_db_select(options["output"]) for vals in data['values'].itervalues(): # unfortunately we need to cast values by float print('NDVI class {0}: {1:.4f} (min) {2:.4f} (max) {3:.4f} (mean)'. format(vals[0], float(vals[2]), float(vals[3]), float(vals[4])))
def main(): #gscript.run_command('g.region', raster='dmt', flags='p') #gscript.run_command('r.univar', map='dmt') Module('g.region', raster='dmt', flags="p") print("-" * 60, "\n") Module("g.message", message="=" * 60) Module("r.univar", map="dmt")
def copy_vectors(vectors, gisrc_src, gisrc_dst): """Copy vectors from one mapset to another, crop the raster to the region. :param vectors: a list of strings with the vector map that must be copied from a master to another. :type vectors: list :param gisrc_src: path of the GISRC file from where we want to copy the groups :type gisrc_src: str :param gisrc_dst: path of the GISRC file where the groups will be created :type gisrc_dst: str :returns: None """ env = os.environ.copy() path_dst = os.path.join(*read_gisrc(gisrc_dst)) nam = "copy%d__%s" % (id(gisrc_dst), "%s") # instantiate modules vpck = Module("v.pack") vupck = Module("v.unpack") remove = Module("g.remove") for vect in vectors: # change gisdbase to src env["GISRC"] = gisrc_src name = nam % vect file_dst = "%s.pack" % os.path.join(path_dst, name) vpck(input=name, output=file_dst, overwrite=True, env_=env) remove(flags="f", type="vector", name=name, env_=env) # change gisdbase to dst env["GISRC"] = gisrc_dst vupck(input=file_dst, output=vect, overwrite=True, env_=env) os.remove(file_dst)
def benchmark(memory, label, results, reference): slope = "benchmark_slope" aspect = "benchmark_aspect" pcurv = "benchmark_pcurv" tcurv = "benchmark_tcurv" module = Module( "r.slope.aspect", elevation=reference, slope=slope, aspect=aspect, pcurvature=pcurv, tcurvature=tcurv, run_=False, stdout_=DEVNULL, overwrite=True, ) results.append( bm.benchmark_nprocs(module, label=label, max_nprocs=20, repeat=10)) Module("g.remove", quiet=True, flags="f", type="raster", name=slope) Module("g.remove", quiet=True, flags="f", type="raster", name=aspect) Module("g.remove", quiet=True, flags="f", type="raster", name=pcurv) Module("g.remove", quiet=True, flags="f", type="raster", name=tcurv)
def main(): mapset = Mapset() mapset.current() with open(options['output'], 'w') as fd: for rast in mapset.glist('raster', pattern='*_B04_10m'): items = rast.split('_') d = datetime.strptime(items[2], '%Y%m%dT%H%M%S') ## workaround dd = d + timedelta(seconds=1) vect = '{}_{}_MSK_CLOUDS'.format(items[1], items[2]) mask_vect = '{}_{}'.format(vect, options['map'].split('@')[0]) if Vector(vect).exist(): Module('v.overlay', ainput=options['map'], binput=vect, operator='not', output=mask_vect) else: copy(options['map'], mask_vect, 'vector') Module('r.mask', vector=mask_vect, overwrite=True) Module('g.remove', flags='f', type='vector', name=mask_vect) Module('g.rename', raster=['MASK', mask_vect]) fd.write("{0}|{1}|{2}{3}".format(mask_vect, d.strftime('%Y-%m-%d %H:%M:%S'), dd.strftime('%Y-%m-%d %H:%M:%S'), os.linesep)) return 0
def _handler(self, request, response): from subprocess import PIPE from grass.pygrass.modules import Module from grass.exceptions import CalledModuleError start = request.inputs['start'][0].data end = request.inputs['end'][0].data self.check_date(start) self.check_date(end) x, y = request.inputs['coords'][0].data.split(',') # be silent os.environ['GRASS_VERBOSE'] = '0' # need to set computation region (would be nice g.region strds or t.region) Module('g.region', raster='c_001') try: ret = Module( 't.rast.what', stdout_=PIPE, strds='modis_c@PERMANENT', coordinates=[x, y], separator=',', where="start_time > '{start}' and start_time < '{end}'".format( start=start, end=end)) except CalledModuleError: raise Exception('Unable to compute statistics') tsum = 0 stats = { 'min': None, 'max': None, 'mean': None, 'count': 0, } count = 0 for line in ret.outputs.stdout.splitlines(): items = line.split(',') if items[-1] == '*': # no data continue val = float(items[-1]) if stats['min'] is None: stats['min'] = stats['max'] = stats['mean'] = val else: if val < stats['min']: stats['min'] = val if val > stats['max']: stats['max'] = val tsum += val stats['count'] += 1 stats['mean'] = tsum / stats['count'] response.outputs['stats'].data = json.dumps(stats) return response
def patch_tiles(maps, output, resolution): gs.message("Patching tiles <{}>...".format(','.join(maps))) Module('g.region', raster=maps, res=resolution) Module('r.series', input=maps, output=output, method='average', overwrite=True) Module('r.colors', map=output, color='elevation')
def generate_map(rows, cols, fname): Module("g.region", flags="p", s=0, n=rows, w=0, e=cols, res=1) # Generate using r.random.surface if r.surf.fractal fails try: print("Generating reference map using r.surf.fractal...") Module("r.surf.fractal", output=fname) except CalledModuleError: print("r.surf.fractal fails, using r.random.surface instead...") Module("r.random.surface", output=fname)
def get_zones(vector, zones, layer=1, overwrite=False): v2rast = Module('v.to.rast', input=vector, layer=str(layer), type='area', output=zones, overwrite=overwrite, rows=65536, use='cat') rclr = Module("r.colors", map=zones, color="random")
def _handler(self, request, response): from subprocess import PIPE import grass.script as gs from grass.pygrass.modules import Module from grass.exceptions import CalledModuleError start1 = request.inputs['start1'][0].data end1 = request.inputs['end1'][0].data self.check_date(start1) self.check_date(end1) start2 = request.inputs['start2'][0].data end2 = request.inputs['end2'][0].data self.check_date(start2) self.check_date(end2) output1 = 'stcVH' output2 = 'stcVV' # be silent os.environ['GRASS_VERBOSE'] = '0' try: Module( 't.rast.series', input='stcubeVH@PERMANENT', output=output1, method='average', where="start_time > '{start}' and start_time < '{end}'".format( start=start1, end=end1)) Module( 't.rast.series', input='stcubeVV@PERMANENT', output=output2, method='average', where="start_time > '{start}' and start_time < '{end}'".format( start=start2, end=end2)) except CalledModuleError: raise Exception('Unable to compute statistics') ret = Module('r.univar', flags='g', map=output1, stdout_=PIPE) ret2 = Module('r.univar', flags='g', map=output2, stdout_=PIPE) stats1 = gs.parse_key_val(ret.outputs.stdout) stats2 = gs.parse_key_val(ret2.outputs.stdout) outstr1 = 'Min1: {0:.1f};Max1: {1:.1f};Mean1: {2:.1f}'.format( float(stats1['min']), float(stats1['max']), float(stats1['mean'])) outstr2 = 'Min2: {0:.1f};Max2: {1:.1f};Mean2: {2:.1f}'.format( float(stats2['min']), float(stats2['max']), float(stats2['mean'])) response.outputs['stats1'].data = outstr1 response.outputs['stats2'].data = outstr2 return response
def viewshed(vrt,list_of_dicts,distance,point, observer_height,grassdb,burn_viewshed_rst,total_cells_output): ## deles op - foerste funktion with rasterio.open(vrt) as src_rst: dsm = src_rst.read() out_meta = src_rst.meta.copy() print(out_meta) out_meta.update(dtype=rasterio.int16,driver='GTiff') mask = features.geometry_mask( [feature["feature"]["geometry"] for feature in list_of_dicts], src_rst.shape, transform=src_rst.transform, all_touched=True, invert=True) new_dsm = np.copy(np.squeeze(dsm)) #Forstaer ikke hvorfor, men dsm'en har en ekstra dimension, #som jeg fjerner med squeeze, saa den passer med result dsm'en ## deles op - anden funktion, maaske with rasterio.Env(): result = features.rasterize( ((feature['feature']['geometry'],np.int(feature['feature']['properties']['hoejde']) * 1000) for feature in list_of_dicts), out_shape=src_rst.shape, transform=src_rst.transform, all_touched=True) new_dsm[mask] = result[mask] ## deles op - tredje funktion with Session(gisdb=grassdb, location="test",create_opts=vrt): import grass.script.array as garray r_viewshed = Module('r.viewshed') r_out_gdal = Module('r.out.gdal') r_stats = Module('r.stats') r_univar = Module('r.univar') from_np_raster = garray.array() from_np_raster[...] = new_dsm from_np_raster.write('ny_rast',overwrite=True) print(from_np_raster) gcore.run_command('r.viewshed', overwrite=True, memory=2000, input='ny_rast', output='viewshed', max_distance=distance, coordinates=point, observer_elevation=observer_height) r_stats(flags='nc',overwrite=True,input='viewshed',output=total_cells_output) ## finde ud af hvordan r_stats kan outputte til noget som ## python kan laese direkte with open(total_cells_output) as tcls: counts = [] for line in tcls: nbr = int(line.split()[-1]) counts.append(nbr) # summary = r_univar(map='viewshed') #r_viewshed(input=from_np_raster, output='viewshed', max_distance=1000, memory=1424, coordinates=(701495,6201503), observer_elevation=500.0) r_out_gdal(overwrite=True, input='viewshed', output=burn_viewshed_rst) return sum(counts) #visible_cells
def load_tests(loader, tests, ignore): # TODO: this must be somewhere when doctest is called, not here # TODO: ultimate solution is not to use _ as a buildin in lib/python # for now it is the only place where it works grass.gunittest.utils.do_doctest_gettext_workaround() # this should be called at some top level from grass.pygrass.modules import Module Module("g.region", n=40, s=0, e=40, w=0, res=10) Module( "r.mapcalc", expression="%s = row() + (10 * col())" % (pgrass.test_raster_name), overwrite=True, ) Module( "r.support", map=pgrass.test_raster_name, title="A test map", history="Generated by r.mapcalc", description="This is a test map", ) cats = """11:A 12:B 13:C 14:D 21:E 22:F 23:G 24:H 31:I 32:J 33:K 34:L 41:M 42:n 43:O 44:P""" Module("r.category", rules="-", map=pgrass.test_raster_name, stdin_=cats, separator=":") Module( "r.mapcalc", expression="%s = row() + (10 * col())" % (pgrass.abstract.test_raster_name), overwrite=True, ) tests.addTests(doctest.DocTestSuite(pgrass)) tests.addTests(doctest.DocTestSuite(pgrass.abstract)) return tests
def clip(inFeat, clipFeat, outFeat, api_gis="grass", clip_by_region=None): """ Clip Analysis api_gis Options: * grass * pygrass * ogr2ogr """ if api_gis == "pygrass": from grass.pygrass.modules import Module if not clip_by_region: vclip = Module("v.clip", input=inFeat, clip=clipFeat, output=outFeat, overwrite=True, run_=False, quiet=True) else: vclip = Module("v.clip", input=inFeat, output=outFeat, overwrite=True, flags='r', run_=False, quiet=True) vclip() elif api_gis == "grass": from gasp import exec_cmd rcmd = exec_cmd( "v.clip input={}{} output={} {}--overwrite --quiet".format( inFeat, " clip={}".format(clipFeat) if clipFeat else "", outFeat, "-r " if not clipFeat else "")) elif api_gis == 'ogr2ogr': from gasp import exec_cmd from gasp.pyt.oss import fprop from gasp.gt.prop.ff import drv_name rcmd = exec_cmd( ("ogr2ogr -f \"{}\" {} {} -clipsrc {} -clipsrclayer {}").format( drv_name(outFeat), outFeat, inFeat, clipFeat, fprop(clipFeat, 'fn'))) else: raise ValueError("{} is not available!".format(api_gis)) return outFeat
def convert_maps(base, date=None, year=None, month=None, startnum=1, log=None): """Convert the data if needed, like temperature from kelvin to celsius""" if isinstance(date, datetime): mydat = deepcopy(date) elif year and month: mydat = datetime(year, month, 1, 0, 0) else: print("Please set date or year with or without month") sys.exit(1) if not date: date = datetime(year, month, 1, 0, 0) if log: fi = open(log, 'w') Module("g.region", raster="{ba}_{mo}.{im}".format(ba=base, im=startnum, mo=date.strftime("%Y_%m"))) for do in range(startnum, 745): out = "{ba}_{da}".format(ba=base, da=mydat.strftime("%Y_%m_%d_%H")) inn = "{ba}_{mo}.{im}".format(ba=base, mo=date.strftime("%Y_%m"), im=do) try: r = RasterRow(inn) r.open() r.close() except: continue if base == 'T_2M': try: mapc = Module("r.mapcalc", expression="{ou} = {inn} - " "273.15".format(ou=out, inn=inn), stdout_=PIPE, stderr_=PIPE) if log: if mapc.outputs.stdout: fi.write("{}\n".format(mapc.outputs.stdout)) if mapc.outputs.stderr: fi.write("{}\n".format(mapc.outputs.stderr)) Module("g.remove", type="raster", name=inn, flags="f") except CalledModuleError: continue elif base == 'TOT_PRECIP': try: mapc = Module("r.mapcalc", expression="{ou} = if({inn} < 0, 0," " {inn})".format(ou=out, inn=inn), stdout_=PIPE, stderr_=PIPE) if log: if mapc.outputs.stdout: fi.write("{}\n".format(mapc.outputs.stdout)) if mapc.outputs.stderr: fi.write("{}\n".format(mapc.outputs.stderr)) Module("g.remove", type="raster", name=inn, flags="f") except CalledModuleError: continue mydat = mydat + timedelta(seconds=3600) if log: fi.close()
def get_zones(vector, zones, layer=1, overwrite=False): v2rast = Module( "v.to.rast", input=vector, layer=str(layer), type="area", output=zones, overwrite=overwrite, use="cat", ) rclr = Module("r.colors", map=zones, color="random")
def _get_streamlist(self, stream): """Compute shape of stream. :param stream: """ Module( 'db.copy', from_table=self.tab_stream_shape, from_database='$GISDBASE/$LOCATION_NAME/PERMANENT/sqlite/sqlite.db', to_table='stream_shape') # TODO: (check if smoderp column exists) sfields = ["number", "shapetype", "b", "m", "roughness", "q365"] try: self._join_table(stream, self.tab_stream_shape_code, 'stream_shape', self.tab_stream_shape_code, sfields) except: self._add_field(stream, "smoderp", "TEXT", "0") self._join_table(stream, self.tab_stream_shape_code, 'stream_shape', self.tab_stream_shape_code, sfields) sfields.insert(1, "smoderp") # TODO: rewrite into pygrass syntax ret = Module('v.db.select', flags='c', map=stream, columns=sfields, stdout_=PIPE) for row in ret.outputs.stdout.splitlines(): for value in row.split('|'): if value == '': raise StreamPreparationError( "Empty value in {} found.".format(stream)) with Vector(stream) as data: self.field_names = data.table.columns.names() self.stream_tmp = [[] for field in self.field_names] # TODO: rewrite into pygrass syntax ret = Module('v.db.select', flags='c', map=stream, columns=self.field_names, stdout_=PIPE) for row in ret.outputs.stdout.splitlines(): i = 0 for val in row.split('|'): self.stream_tmp[i].append(float(val)) i += 1 self.streamlist = [] self._streamlist()
def import_shapefile(path_to_shape, shapename, overwrite_bool): """ imports the boundary of the area of investigation :param path_to_shape: string Path to folder, where the shapefile is :param overwrite_bool: bool Option of True or False, but True is strongly recommended! :return: """ ogrimport = Module("v.in.ogr") ogrimport(path_to_shape, overwrite=overwrite_bool) showregion = Module("g.region") showregion(flags='p', overwrite=overwrite_bool, vector=shapename)
def obce_psc(self, psc): map_name = 'obce_psc_{}'.format(psc) Module('v.extract', input='obce', output='obce1', where="psc = '{}'".format(psc)) Module('v.select', ainput='obce', binput='obce1', output=map_name, operator='overlap', overwrite=True) return map_name
def benchmark(memory, label, results, reference): output = "benchmark_r_neighbors_nprocs" module = Module( "r.neighbors", input=reference, output=output, size=9, memory=memory, run_=False, stdout_=DEVNULL, overwrite=True, ) results.append(bm.benchmark_nprocs(module, label=label, max_nprocs=16, repeat=3)) Module("g.remove", quiet=True, flags="f", type="raster", name=output)
def convert(inLyr, outLyr, geom_type=None): """ Add or export data from/to GRASS GIS """ import os if os.path.splitext(inLyr)[1] in VectorialDrivers(): inOrOut = 'import' data = 'vector' elif os.path.splitext(inLyr)[1] in RasterDrivers(): inOrOut = 'import' data = 'raster' else: outFormat = os.path.splitext(outLyr)[1] inOrOut = 'export' if outFormat in VectorialDrivers(): data = 'vector' elif outFormat in RasterDrivers(): data = 'raster' else: raise ValueError( "Not possible to identify if you want export or import data" ) #*************************************************************************# if data == 'vector': if inOrOut == 'import': m = Module('v.in.ogr', input=inLyr, output=outLyr, flags='o', overwrite=True, run_=False, quiet=True) elif inOrOut == 'export': m = Module('v.out.ogr', input=inLyr, type=geom_type, output=outLyr, format=VectorialDrivers()[outFormat], overwrite=True, run_=False, quiet=True) elif data == 'raster': if inOrOut == 'import': m = Module("r.in.gdal", input=inLyr, output=outLyr, flags='o', overwrite=True, run_=False, quiet=True) elif inOrOut == 'export': m = Module("r.out.gdal", input=inLyr, output=outLyr, format=RasterDrivers()[outFormat], overwrite=True, run_=False, quiet=True) m()
def copy_insame_vector(inShp, colToBePopulated, srcColumn, destinyLayer, geomType="point,line,boundary,centroid", asCMD=None): """ Copy Field values from one layer to another in the same GRASS Vector """ if not asCMD: from grass.pygrass.modules import Module vtodb = Module("v.to.db", map=inShp, layer=destinyLayer, type=geomType, option="query", columns=colToBePopulated, query_column=srcColumn, run_=False, quiet=True) vtodb() else: from glass.pys import execmd rcmd = execmd( ("v.to.db map={} layer={} type={} option=query columns={} " "query_column={} --quiet").format(inShp, destinyLayer, geomType, colToBePopulated, srcColumn))
def stats(output, date, fd): fd.write('-' * 80) fd.write(os.linesep) fd.write('NDVI class statistics ({0}: {1})'.format(output, date)) fd.write(os.linesep) fd.write('-' * 80) fd.write(os.linesep) from subprocess import PIPE ret = Module('v.report', map=output, option='area', stdout_=PIPE) for line in ret.outputs.stdout.splitlines( )[1:]: # skip first line (cat|label|area) # parse line (eg. 1||2712850) data = line.split('|') cat = data[0] area = float(data[-1]) fd.write('NDVI class {0}: {1:.1f} ha'.format(cat, area / 1e4)) fd.write(os.linesep) data = vector_db_select(output) for vals in data['values'].values(): # unfortunately we need to cast values by float fd.write('NDVI class {0}: {1:.4f} (min) {2:.4f} (max) {3:.4f} (mean)'. format(vals[0], float(vals[2]), float(vals[3]), float(vals[4]))) fd.write(os.linesep)
def grs_to_rst(grsRst, rst, as_cmd=None, allBands=None): """ GRASS Raster to Raster """ from gasp.prop.ff import RasterDrivers from gasp.oss import get_fileformat rstDrv = RasterDrivers() rstExt = get_fileformat(rst) if not as_cmd: from grass.pygrass.modules import Module m = Module( "r.out.gdal", input=grsRst, output=rst, format=rstDrv[rstExt], flags='c' if not allBands else '', createopt="INTERLEAVE=PIXEL,TFW=YES" if allBands else '', overwrite=True, run_=False, quiet=True ) m() else: from gasp import exec_cmd rcmd = exec_cmd(( "r.out.gdal input={} output={} format={} " "{} --overwrite --quiet" ).format( grsRst, rst, rstDrv[rstExt], "-c" if not allBands else "createopt=\"INTERLEAVE=PIXEL,TFW=YES\"" )) return rst