def parse_alias(alias_file): """Parse alias file if provided""" if alias_file: if not os.access(alias_file, os.R_OK): gscript.fatal( _("Alias file <{}> not found or not readable".format( alias_file))) with open(alias_file, "r") as a_f: alias_dict = gscript.parse_key_val(a_f.read(), sep=",") else: alias_dict = None if alias_dict: for alias, full_name in alias_dict.items(): # Skip invaid lines if not alias or not full_name: continue # Check if environmental parameter map(s) exist if "@" in full_name: raster, mapset = full_name.split("@") else: raster, mapset = full_name, "" raster_map = RasterRow(full_name) # raster, mapset) mapset = "." if not mapset else mapset if not raster_map.exist(): gscript.fatal( _("Could not find environmental parameter raster map <{}> in mapset <{}>." .format(raster, mapset))) return alias_dict
def _get_raster_image_as_np(lock, conn, data): """Convert a raster map into an image and return a numpy array with RGB or Gray values. :param lock: A multiprocessing.Lock instance :param conn: A multiprocessing.Pipe instance used to send True or False :param data: The list of data entries [function_id, raster_name, extent, color] """ array = None try: name = data[1] mapset = data[2] extent = data[3] color = data[4] mapset = utils.get_mapset_raster(name, mapset) if not mapset: raise ValueError("Unable to find raster map <%s>" % (name)) rast = RasterRow(name, mapset) if rast.exist(): reg = Region() reg.from_rast(name) if extent is not None: if "north" in extent: reg.north = extent["north"] if "south" in extent: reg.south = extent["south"] if "east" in extent: reg.east = extent["east"] if "west" in extent: reg.west = extent["west"] if "rows" in extent: reg.rows = extent["rows"] if "cols" in extent: reg.cols = extent["cols"] reg.adjust() array = raster2numpy_img(name, reg, color) finally: # Send even if an exception was raised. conn.send(array)
def parse_species_input(species_masks, species_names): """Parse species input""" species_dict = {} if species_masks: species_masks = species_masks.split(",") if species_names: species_names = species_names.split(",") # Check if number of specie names is identically with number of specie maps if species_names and species_masks: if len(species_names) != len(species_masks): gscript.fatal( _( "Number of provided species input maps and species names do not match." ) ) if species_masks: for idx, species in enumerate(species_masks): # Check if species map exist species_map_name = species.split("@") species_name = species_names[idx] if species_names else species_map_name[0] species_map = RasterRow(*species_map_name) if not species_map.exist(): gscript.fatal( _( "Could not find species raster map <{}> in mapset <{}>.".format( *species_map_name ) ) ) species_dict[species_name] = species_map_name return species_dict
def test_exist(self): notexist = RasterRow(self.name + 'notexist') self.assertFalse(notexist.exist()) exist = RasterRow(self.name) self.assertTrue(exist.exist())
def main(): options, flags = g.parser() Blue = options["blue_band"] Green = options["green_band"] Red = options["red_band"] NIR = options["nir_band"] SWIR = options["band_for_correction"] Calibration_points = options["calibration_points"] Area_of_interest = options["area_of_interest"] Additional_band1 = options["additional_band1"] Additional_band2 = options["additional_band2"] Additional_band3 = options["additional_band3"] Additional_band4 = options["additional_band4"] bathymetry = options["depth_estimate"] tide_height = options["tide_height"] calibration_column = options["calibration_column"] bisquare = flags["b"] fixed_GWR = flags["f"] res = g.parse_command("g.region", raster=Green, flags="g") g.run_command( "v.to.rast", input=Calibration_points, type="point", use="attr", attribute_column=calibration_column, output="tmp_Calibration_points", ) # hull generation from calibration depth points g.run_command("v.hull", input=Calibration_points, output="tmp_hull", overwrite=True) # buffer the hull to ceate a region for including all calibration points g.run_command( "v.buffer", input="tmp_hull", output="tmp_buffer", distance=float(res["nsres"]), overwrite=True, ) if tide_height: cal = g.parse_command("r.univar", map="tmp_Calibration_points", flags="g") if float(cal["min"]) >= 0: t = float(tide_height) g.mapcalc( exp="{d}=({d}+float({t}))".format(d="tmp_Calibration_points", t=t), overwrite=True, ) if float(cal["min"]) < 0: t = float(tide_height) * -1 g.mapcalc( exp="{d}=({d}+float({t}))".format(d="tmp_Calibration_points", t=t), overwrite=True, ) g.mapcalc(exp="{tmp_ratio}=({Green}/{SWIR})".format( tmp_ratio="tmp_ratio", Green=Green, SWIR=SWIR)) g.mapcalc(exp="{tmp_NDVI}=float({NIR}-{Red})/float({NIR}+{Red})".format( tmp_NDVI="tmp_NDVI", NIR=NIR, Red=Red)) g.mapcalc( exp="{tmp_water}=if({tmp_ratio} < 1, null(), if({tmp_NDVI} <" "0, {tmp_ratio}, null()))".format( tmp_NDVI="tmp_NDVI", tmp_water="tmp_water", tmp_ratio="tmp_ratio")) g.run_command("r.mask", raster="tmp_water", overwrite=True) li = [ Green, Additional_band1, Additional_band2, Additional_band3, Additional_band4, Blue, Red, ] for i in li: j, sep, tail = i.partition("@") tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue g.message("Ditermining minimum value for %s" % i) g.run_command("g.region", vector=Calibration_points) # To ignore zero values g.mapcalc( exp="{tmp_b}=if({x}>1, {x},null())".format(tmp_b="tmp_b", x=str(i)), overwrite=True, ) tmp_AOI = g.parse_command("r.univar", map="tmp_b", flags="g") tmp_AOI_min = float(tmp_AOI["min"]) g.run_command("g.region", raster=Green) try: g.mapcalc( exp="{tmp_deep}=if({tmp_band}<{band_min}, {tmp_band}," "null())".format(tmp_deep="tmp_deep", band_min=tmp_AOI_min, tmp_band=str(i)), overwrite=True, ) g.run_command("r.mask", raster="tmp_deep", overwrite=True) tmp_coe = g.parse_command("r.regression.line", mapx=SWIR, mapy=str(i), flags="g") g.message("Deep water ditermination for %s" % i) if Area_of_interest: g.run_command("r.mask", vector=Area_of_interest, overwrite=True) g.run_command("g.region", vector=Area_of_interest) else: g.run_command("r.mask", vector="tmp_buffer", overwrite=True) g.run_command("g.region", vector=Calibration_points) g.mapcalc( exp="{tmp_crct}=log({tmp_band}-{a}-{b}*{SWIR})".format( tmp_crct="tmp_crct" + str(j), tmp_band=str(i), a=float(tmp_coe["a"]), b=float(tmp_coe["b"]), SWIR=SWIR, ), overwrite=True, ) g.run_command("r.mask", raster="tmp_water", overwrite=True) g.mapcalc("{tmp_crctd} = ({tmp_crct} * 1)".format( tmp_crct="tmp_crct" + str(j), tmp_crctd="tmp_crctd" + str(j))) except: g.message("Cannot find deep water pixels") if Area_of_interest: g.run_command("r.mask", vector=Area_of_interest, overwrite=True) g.run_command("g.region", vector=Area_of_interest) else: g.run_command("r.mask", vector="tmp_buffer", overwrite=True) g.run_command("g.region", vector=Calibration_points) g.mapcalc( exp="{tmp_crct}=log({tmp_band}-{a}-{b}*{SWIR})".format( tmp_crct="tmp_crct" + str(j), tmp_band=str(i), a=float(tmp_coe["a"]), b=float(tmp_coe["b"]), SWIR=SWIR, ), overwrite=True, ) g.run_command("r.mask", raster="tmp_water", overwrite=True) g.mapcalc("{tmp_crctd} = ({tmp_crct} * 1)".format( tmp_crct="tmp_crct" + str(j), tmp_crctd="tmp_crctd" + str(j))) crctd_lst.append("tmp_crctd" + str(j)) if fixed_GWR: if not g.find_program("r.gwr", "--help"): g.run_command("g.extension", extension="r.gwr") if bisquare: g.message("Calculating optimal bandwidth using bisqare kernel...") bw = g.parse_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", kernel="bisquare", flags="ge", ) g.message("Running Fixed-GWR using bisqare kernel...") g.run_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", estimates="tmp_bathymetry", kernel="bisquare", bandwidth=int(bw["estimate"]), ) else: g.message("Calculating optimal bandwidth using gaussian kernel...") bw = g.parse_command("r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", flags="ge") g.message("Running Fixed-GWR using gaussian kernel...") g.run_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", estimates="tmp_bathymetry", bandwidth=int(bw["estimate"]), ) else: global r global predict try: # For GWmodel in R r = g.tempfile() r_file = open(r, "w") libs = ["GWmodel", "data.table", "rgrass7", "rgdal", "raster"] for i in libs: install = 'if(!is.element("%s", installed.packages()[,1])){\n' % i install += "cat('\\n\\nInstalling %s package from CRAN\n')\n" % i install += "if(!file.exists(Sys.getenv('R_LIBS_USER'))){\n" install += "dir.create(Sys.getenv('R_LIBS_USER'), recursive=TRUE)\n" install += ".libPaths(Sys.getenv('R_LIBS_USER'))}\n" install += ('install.packages("%s", repos="http://cran.us.r-' 'project.org")}\n' % i) r_file.write(install) libraries = "library(%s)\n" % i r_file.write(libraries) Green_new, sep, tail = Green.partition("@") r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % Green_new) r_file.write("raster_file = raster(grass_file)\n") frame_file = "pred = as.data.frame(raster_file,na.rm = TRUE,xy = TRUE)\n" r_file.write(frame_file) for i in li: j, sep, tail = i.partition("@") Green_new, sep, tail = Green.partition("@") tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % j) r_file.write("raster_file = raster(grass_file)\n") r_file.write( "frame_pred%s = as.data.frame(raster_file, na.rm = TRUE," "xy = TRUE)\n" % j) pred_file = "frame_pred_green=data.frame(frame_pred%s)\n" % Green_new pred_file += "pred=merge(pred, frame_pred%s)\n" % j r_file.write(pred_file) # For reference_file repeat with MASK g.run_command("r.mask", raster="tmp_Calibration_points", overwrite=True) r_file.write('grass_file=readRAST("%s")\n' % "tmp_Calibration_points") r_file.write("raster_file = raster(grass_file)\n") frame_file = ( "calib = as.data.frame(raster_file,na.rm = TRUE ," "xy = TRUE)\n") r_file.write(frame_file) for i in li: j, sep, tail = i.partition("@") tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % j) r_file.write("raster_file = raster(grass_file)\n") r_file.write( "frame_ref%s = as.data.frame(raster_file,na.rm = TRUE," "xy = TRUE)\n" % j) ref_file = "calib = merge(calib, frame_ref%s)\n" % j r_file.write(ref_file) g.run_command("g.remove", type="raster", pattern="MASK", flags="f") ref_file = "Rapid_ref.sdf=SpatialPointsDataFrame(calib[,1:2],calib)\n" ref_file += "Rapid_pred.sdf=SpatialPointsDataFrame(pred[,1:2]," "pred)\n" ref_file += ("DM_Rapid_ref.sdf=gw.dist(dp.locat=coordinates" "(Rapid_ref.sdf))\n") r_file.write(ref_file) l = [] predict = g.read_command("g.tempfile", pid=os.getpid()).strip() + ".txt" # Join the corrected bands in to a string le = len(crctd_lst) for i in crctd_lst: l.append(i) k = "+".join(l) if bisquare: ref_flag = ("cat('\nCalculating optimal bandwidth using " "bisquare kernel..\n')\n") ref_flag += ( "BW_Rapid_ref.sdf=bw.gwr(tmp_Calibration_points~%s," 'data=Rapid_ref.sdf, kernel="bisquare",' "adaptive=TRUE, dMat=DM_Rapid_ref.sdf)\n" % k) ref_flag += "cat('\nCalculating euclidean distance\n')\n" ref_flag += ("DM_Rapid_pred.sdf=gw.dist(dp.locat=coordinates" "(Rapid_ref.sdf), rp.locat=coordinates" "(Rapid_pred.sdf))\n") ref_flag += "cat('\nRunning A-GWR using bisquare kernel\n')\n" ref_flag += ( "GWR_Rapid_pred.sdf=gwr.predict(tmp_Calibration_poi" "nts~%s,data=Rapid_ref.sdf, bw = BW_Rapid_ref.sdf," 'predictdata = Rapid_pred.sdf, kernel = "bisquare",' "adaptive = TRUE, dMat1 = DM_Rapid_pred.sdf," "dMat2 = DM_Rapid_ref.sdf)\n" % k) r_file.write(ref_flag) if not bisquare: ref_fla = ("cat('\nCalculating optimal bandwidth using " "gaussian kernel..\n')\n") ref_fla += ( "BW_Rapid_ref.sdf=bw.gwr(tmp_Calibration_points~%s," 'data=Rapid_ref.sdf, kernel="gaussian",' "adaptive=TRUE, dMat= DM_Rapid_ref.sdf)\n" % k) ref_fla += "cat('\nCalculating euclidean distance\n')\n" ref_fla += ("DM_Rapid_pred.sdf=gw.dist(dp.locat=coordinates" "(Rapid_ref.sdf), rp.locat=coordinates" "(Rapid_pred.sdf))\n") ref_fla += "cat('\nRunning A-GWR using gaussian kernel\n')\n" ref_fla += ( "GWR_Rapid_pred.sdf = gwr.predict(tmp_Calibration_poi" "nts~%s,data=Rapid_ref.sdf, bw=BW_Rapid_ref.sdf," 'predictdata = Rapid_pred.sdf, kernel = "gaussian",' "adaptive = TRUE, dMat1 = DM_Rapid_pred.sdf," "dMat2 = DM_Rapid_ref.sdf)\n" % k) r_file.write(ref_fla) ref_fil = "Sp_frame = as.data.frame(GWR_Rapid_pred.sdf$SDF)\n" r_file.write(ref_fil) export = 'write.table(Sp_frame, quote=FALSE, sep=",",' '"%s")\n' % predict r_file.write(export) r_file.close() subprocess.check_call(["Rscript", r], shell=False) g.run_command( "r.in.xyz", input=predict, output="tmp_bathymetry", skip=1, separator=",", x=(int(le) + 5), y=(int(le) + 6), z=(int(le) + 3), overwrite=True, ) except subprocess.CalledProcessError: g.message("Integer outflow... ") if not g.find_program("r.gwr", "--help"): g.run_command("g.extension", extension="r.gwr") if bisquare: g.message("Running Fixed-GWR using bisqare kernel...") bw = g.parse_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", kernel="bisquare", flags="ge", ) g.run_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", estimates="tmp_bathymetry", kernel="bisquare", bandwidth=int(bw["estimate"]), ) else: g.message("Running Fixed-GWR using gaussian kernel...") bw = g.parse_command("r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", flags="ge") g.run_command( "r.gwr", mapx=crctd_lst, mapy="tmp_Calibration_points", estimates="tmp_bathymetry", bandwidth=int(bw["estimate"]), ) tmp_rslt_ext = g.parse_command("r.univar", map="tmp_Calibration_points", flags="g") g.mapcalc(exp="{bathymetry}=if({tmp_SDB}>{max_}, null()," "if({tmp_SDB}<{min_}, null(), {tmp_SDB}))".format( tmp_SDB="tmp_bathymetry", bathymetry=bathymetry, max_=float(tmp_rslt_ext["max"]), min_=float(tmp_rslt_ext["min"]), ))
def main(): options, flags = g.parser() Blue = options['blue_band'] Green = options['green_band'] Red = options['red_band'] NIR = options['nir_band'] SWIR = options['band_for_correction'] Calibration_points = options['calibration_points'] Area_of_interest = options['area_of_interest'] Additional_band1 = options['additional_band1'] Additional_band2 = options['additional_band2'] Additional_band3 = options['additional_band3'] Additional_band4 = options['additional_band4'] bathymetry = options['depth_estimate'] tide_height = options['tide_height'] calibration_column = options['calibration_column'] bisquare = flags['b'] fixed_GWR = flags['f'] res = g.parse_command('g.region', raster=Green, flags='g') g.run_command('v.to.rast', input=Calibration_points, type='point', use='attr', attribute_column=calibration_column, output='tmp_Calibration_points') # hull generation from calibration depth points g.run_command('v.hull', input=Calibration_points, output='tmp_hull', overwrite=True) # buffer the hull to ceate a region for including all calibration points g.run_command('v.buffer', input='tmp_hull', output='tmp_buffer', distance=float(res['nsres']), overwrite=True) if tide_height: cal = g.parse_command('r.univar', map='tmp_Calibration_points', flags='g') if float(cal['min']) >= 0: t = float(tide_height) g.mapcalc(exp="{d}=({d}+float({t}))".format( d='tmp_Calibration_points', t=t), overwrite=True) if float(cal['min']) < 0: t = float(tide_height) * -1 g.mapcalc(exp="{d}=({d}+float({t}))".format( d='tmp_Calibration_points', t=t), overwrite=True) g.mapcalc(exp="{tmp_ratio}=({Green}/{SWIR})".format( tmp_ratio='tmp_ratio', Green=Green, SWIR=SWIR)) g.mapcalc(exp="{tmp_NDVI}=float({NIR}-{Red})/float({NIR}+{Red})".format( tmp_NDVI='tmp_NDVI', NIR=NIR, Red=Red)) g.mapcalc( exp="{tmp_water}=if({tmp_ratio} < 1, null(), if({tmp_NDVI} <" "0, {tmp_ratio}, null()))".format( tmp_NDVI='tmp_NDVI', tmp_water='tmp_water', tmp_ratio='tmp_ratio')) g.run_command('r.mask', raster='tmp_water', overwrite=True) li = [ Green, Additional_band1, Additional_band2, Additional_band3, Additional_band4, Blue, Red ] for i in li: j, sep, tail = i.partition('@') tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue g.message("Ditermining minimum value for %s" % i) g.run_command('g.region', vector=Calibration_points) # To ignore zero values g.mapcalc(exp="{tmp_b}=if({x}>1, {x},null())".format(tmp_b='tmp_b', x=str(i)), overwrite=True) tmp_AOI = g.parse_command('r.univar', map='tmp_b', flags='g') tmp_AOI_min = float(tmp_AOI['min']) g.run_command('g.region', raster=Green) try: g.mapcalc(exp="{tmp_deep}=if({tmp_band}<{band_min}, {tmp_band}," "null())".format(tmp_deep='tmp_deep', band_min=tmp_AOI_min, tmp_band=str(i)), overwrite=True) g.run_command('r.mask', raster='tmp_deep', overwrite=True) tmp_coe = g.parse_command('r.regression.line', mapx=SWIR, mapy=str(i), flags='g') g.message("Deep water ditermination for %s" % i) if Area_of_interest: g.run_command('r.mask', vector=Area_of_interest, overwrite=True) g.run_command('g.region', vector=Area_of_interest) else: g.run_command('r.mask', vector='tmp_buffer', overwrite=True) g.run_command('g.region', vector=Calibration_points) g.mapcalc(exp="{tmp_crct}=log({tmp_band}-{a}-{b}*{SWIR})".format( tmp_crct='tmp_crct' + str(j), tmp_band=str(i), a=float(tmp_coe['a']), b=float(tmp_coe['b']), SWIR=SWIR), overwrite=True) g.run_command('r.mask', raster='tmp_water', overwrite=True) g.mapcalc("{tmp_crctd} = ({tmp_crct} * 1)".format( tmp_crct='tmp_crct' + str(j), tmp_crctd='tmp_crctd' + str(j))) except: g.message("Cannot find deep water pixels") if Area_of_interest: g.run_command('r.mask', vector=Area_of_interest, overwrite=True) g.run_command('g.region', vector=Area_of_interest) else: g.run_command('r.mask', vector='tmp_buffer', overwrite=True) g.run_command('g.region', vector=Calibration_points) g.mapcalc(exp="{tmp_crct}=log({tmp_band}-{a}-{b}*{SWIR})".format( tmp_crct='tmp_crct' + str(j), tmp_band=str(i), a=float(tmp_coe['a']), b=float(tmp_coe['b']), SWIR=SWIR), overwrite=True) g.run_command('r.mask', raster='tmp_water', overwrite=True) g.mapcalc("{tmp_crctd} = ({tmp_crct} * 1)".format( tmp_crct='tmp_crct' + str(j), tmp_crctd='tmp_crctd' + str(j))) crctd_lst.append('tmp_crctd' + str(j)) if fixed_GWR: if not g.find_program('r.gwr', '--help'): g.run_command('g.extension', extension='r.gwr') if bisquare: g.message("Calculating optimal bandwidth using bisqare kernel...") bw = g.parse_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', kernel='bisquare', flags='ge') g.message("Running Fixed-GWR using bisqare kernel...") g.run_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', estimates='tmp_bathymetry', kernel='bisquare', bandwidth=int(bw['estimate'])) else: g.message("Calculating optimal bandwidth using gaussian kernel...") bw = g.parse_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', flags='ge') g.message("Running Fixed-GWR using gaussian kernel...") g.run_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', estimates='tmp_bathymetry', bandwidth=int(bw['estimate'])) else: global r global predict try: # For GWmodel in R r = g.tempfile() r_file = open(r, 'w') libs = ['GWmodel', 'data.table', 'rgrass7', 'rgdal', 'raster'] for i in libs: install = 'if(!is.element("%s", installed.packages()[,1])){\n' % i install += "cat('\\n\\nInstalling %s package from CRAN\n')\n" % i install += "if(!file.exists(Sys.getenv('R_LIBS_USER'))){\n" install += "dir.create(Sys.getenv('R_LIBS_USER'), recursive=TRUE)\n" install += ".libPaths(Sys.getenv('R_LIBS_USER'))}\n" install += 'install.packages("%s", repos="http://cran.us.r-' \ 'project.org")}\n' % i r_file.write(install) libraries = 'library(%s)\n' % i r_file.write(libraries) Green_new, sep, tail = Green.partition('@') r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % Green_new) r_file.write('raster_file = raster(grass_file)\n') frame_file = 'pred = as.data.frame(raster_file,na.rm = TRUE,xy = TRUE)\n' r_file.write(frame_file) for i in li: j, sep, tail = i.partition('@') Green_new, sep, tail = Green.partition('@') tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % j) r_file.write('raster_file = raster(grass_file)\n') r_file.write( 'frame_pred%s = as.data.frame(raster_file, na.rm = TRUE,' 'xy = TRUE)\n' % j) pred_file = 'frame_pred_green=data.frame(frame_pred%s)\n' % Green_new pred_file += 'pred=merge(pred, frame_pred%s)\n' % j r_file.write(pred_file) # For reference_file repeat with MASK g.run_command('r.mask', raster='tmp_Calibration_points', overwrite=True) r_file.write('grass_file=readRAST("%s")\n' % 'tmp_Calibration_points') r_file.write('raster_file = raster(grass_file)\n') frame_file = 'calib = as.data.frame(raster_file,na.rm = TRUE ,' \ 'xy = TRUE)\n' r_file.write(frame_file) for i in li: j, sep, tail = i.partition('@') tmp_ = RasterRow(str(i)) if tmp_.exist() is False: continue r_file.write('grass_file = readRAST("tmp_crctd%s")\n' % j) r_file.write('raster_file = raster(grass_file)\n') r_file.write( 'frame_ref%s = as.data.frame(raster_file,na.rm = TRUE,' 'xy = TRUE)\n' % j) ref_file = 'calib = merge(calib, frame_ref%s)\n' % j r_file.write(ref_file) g.run_command('g.remove', type='raster', pattern='MASK', flags='f') ref_file = 'Rapid_ref.sdf=SpatialPointsDataFrame(calib[,1:2],calib)\n' ref_file += 'Rapid_pred.sdf=SpatialPointsDataFrame(pred[,1:2],' \ 'pred)\n' ref_file += 'DM_Rapid_ref.sdf=gw.dist(dp.locat=coordinates' \ '(Rapid_ref.sdf))\n' r_file.write(ref_file) l = [] predict = g.read_command("g.tempfile", pid=os.getpid()).strip() + '.txt' # Join the corrected bands in to a string le = len(crctd_lst) for i in crctd_lst: l.append(i) k = '+'.join(l) if bisquare: ref_flag = "cat('\nCalculating optimal bandwidth using " \ "bisquare kernel..\n')\n" ref_flag += 'BW_Rapid_ref.sdf=bw.gwr(tmp_Calibration_points~%s,' \ 'data=Rapid_ref.sdf, kernel="bisquare",' \ 'adaptive=TRUE, dMat=DM_Rapid_ref.sdf)\n' % k ref_flag += "cat('\nCalculating euclidean distance\n')\n" ref_flag += 'DM_Rapid_pred.sdf=gw.dist(dp.locat=coordinates' \ '(Rapid_ref.sdf), rp.locat=coordinates' \ '(Rapid_pred.sdf))\n' ref_flag += "cat('\nRunning A-GWR using bisquare kernel\n')\n" ref_flag += 'GWR_Rapid_pred.sdf=gwr.predict(tmp_Calibration_poi' \ 'nts~%s,data=Rapid_ref.sdf, bw = BW_Rapid_ref.sdf,' \ 'predictdata = Rapid_pred.sdf, kernel = "bisquare",' \ 'adaptive = TRUE, dMat1 = DM_Rapid_pred.sdf,' \ 'dMat2 = DM_Rapid_ref.sdf)\n' % k r_file.write(ref_flag) if not bisquare: ref_fla = "cat('\nCalculating optimal bandwidth using " \ "gaussian kernel..\n')\n" ref_fla += 'BW_Rapid_ref.sdf=bw.gwr(tmp_Calibration_points~%s,' \ 'data=Rapid_ref.sdf, kernel="gaussian",' \ 'adaptive=TRUE, dMat= DM_Rapid_ref.sdf)\n' % k ref_fla += "cat('\nCalculating euclidean distance\n')\n" ref_fla += 'DM_Rapid_pred.sdf=gw.dist(dp.locat=coordinates' \ '(Rapid_ref.sdf), rp.locat=coordinates' \ '(Rapid_pred.sdf))\n' ref_fla += "cat('\nRunning A-GWR using gaussian kernel\n')\n" ref_fla += 'GWR_Rapid_pred.sdf = gwr.predict(tmp_Calibration_poi' \ 'nts~%s,data=Rapid_ref.sdf, bw=BW_Rapid_ref.sdf,' \ 'predictdata = Rapid_pred.sdf, kernel = "gaussian",' \ 'adaptive = TRUE, dMat1 = DM_Rapid_pred.sdf,' \ 'dMat2 = DM_Rapid_ref.sdf)\n' % k r_file.write(ref_fla) ref_fil = 'Sp_frame = as.data.frame(GWR_Rapid_pred.sdf$SDF)\n' r_file.write(ref_fil) export = 'write.table(Sp_frame, quote=FALSE, sep=",",' \ '"%s")\n' % predict r_file.write(export) r_file.close() subprocess.check_call(['Rscript', r], shell=False) g.run_command('r.in.xyz', input=predict, output='tmp_bathymetry', skip=1, separator=",", x=(int(le) + 5), y=(int(le) + 6), z=(int(le) + 3), overwrite=True) except subprocess.CalledProcessError: g.message("Integer outflow... ") if not g.find_program('r.gwr', '--help'): g.run_command('g.extension', extension='r.gwr') if bisquare: g.message("Running Fixed-GWR using bisqare kernel...") bw = g.parse_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', kernel='bisquare', flags='ge') g.run_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', estimates='tmp_bathymetry', kernel='bisquare', bandwidth=int(bw['estimate'])) else: g.message("Running Fixed-GWR using gaussian kernel...") bw = g.parse_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', flags='ge') g.run_command('r.gwr', mapx=crctd_lst, mapy='tmp_Calibration_points', estimates='tmp_bathymetry', bandwidth=int(bw['estimate'])) tmp_rslt_ext = g.parse_command('r.univar', map='tmp_Calibration_points', flags='g') g.mapcalc(exp="{bathymetry}=if({tmp_SDB}>{max_}, null()," "if({tmp_SDB}<{min_}, null(), {tmp_SDB}))".format( tmp_SDB='tmp_bathymetry', bathymetry=bathymetry, max_=float(tmp_rslt_ext['max']), min_=float(tmp_rslt_ext['min'])))