예제 #1
0
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'
예제 #2
0
def getValOnPolys(inmap,poly,elev,dist,output):
	n = getAreasNum(inmap)
	for i in range(n-1):
		# extract one feature from points set with cat value.
		g.run_command("v.extract",input=poly,output="tmp",type="area",layer=1,new=-1,list=i+1,quiet=True,overwrite=True)
		# Add a new column for storing a new value.
		g.run_command("v.db.addcol",map="tmp",columns="val int")                    
		# set default value as 1.
		g.run_command("v.db.update",map="tmp",column="val",value=1,quiet=True)
		# Redefine geographic region for procedure.
		g.run_command("g.region",vect="tmp",quiet=True)
		# convert vector map buffer to raster map buffer.
		g.run_command("v.to.rast",input="tmp",output="tmprast",use="val",overwrite=True,quiet=True)
		# get elevation on the raster buffer.
		g.run_command("r.mapcalculator",amap="tmprast",bmap=elev,formula="A*B",outfile="tmprast2",overwrite=True,quiet=True)
		pix = g.parse_command("r.stats",flags="1",input="tmprast2",nv="",fs=",",quiet=True)
		res = "ID_" + str(i+1)                    
		for j in pix.keys():
			res = str(res) + str(j) + ","
		# Write the result to text file
		file = open(output + str(i+1) + ".txt", "w")
		file.write(res)
		file.write("\n")
		file.close()
		# Remove temporal features
		g.parse_command("g.remove",vect="tmp",rast="tmprast,tmprast2",quiet=True)
		# Set region with DEM.
		g.parse_command("g.region",rast=elv,quiet=True)
예제 #3
0
def main(iters,bounds,padding,sampres,sampint,repeats,sampdist,prefix):
    '''Main set of code for the sampling simulation'''
    #set the sample universe size to the maximum boundaries, and  set the resolution to match the sample size
    grass.run_command("g.region", quiet = True, n=(bounds + padding + padding), s=0, e=(bounds + padding + padding), w=0, res=sampres)
    # calculate the real binary presence/absence map for the input distribution (to compare with the sampled presabs)
    realpresab = "%s_real_presab" % prefix
    grass.mapcalc("${realpresab}=if(${sampdist} > 0, 1, 0)", overwrite = True, quiet = True, sampdist = sampdist, realpresab = realpresab)
    #extract the number of squares that have at least one artifact
    truepres = int(grass.parse_command("r.stats", quiet = True, flags="cn", input=realpresab, separator="=")["1"])
    #set up statsfile
    f = open('%s%s%s_stats.csv' % (os.getcwd(), os.sep, prefix), 'w+')
    f.write("Iteration,Positives,True Positives,Difference,Pcnt Difference,R,R2\n")
    f.flush()
    #initiate the outer loop, which will randomly rotate/move the sampling grid within the sampling universe
    pad = len(str(repeats)) # set the zfill pad to match the number of repeats
    for x in range(repeats):
        grass.message("Iteration: %s" % (x + 1))
        jitt1 = random.randint(0,sampint) # get a random seed for the Y offset
        jitt2 = random.randint(0,sampint) # get a random seed for the X offset
        rot = random.randint(0,360) # get a random seed for the grid rotation
        #reset the sample universe size and resolution
        grass.run_command("g.region", quiet = True, n=(bounds + padding - jitt1), s=padding - jitt1, e=(bounds + padding - jitt2), w=padding - jitt2, res=sampres)
        #make the sampling frame from the sampling interval, the current jitter, and the current rotation
        init_grid = "%s_%s_vgridpts" % (prefix,str(x + 1).zfill(pad))
        init_sqrs = "%s_%s_gridpts" % (prefix,str(x + 1).zfill(pad))
        grass.run_command("v.mkgrid", quiet = True, overwrite = True, map=init_grid, box="%s,%s" % (sampint,sampint), angle=rot, type="point")
        grass.run_command("v.to.rast", quiet = True, overwrite = True, input=init_grid, type="point", output=init_sqrs, use="val")
        # zoom out to the padding distance
        grass.run_command("g.region", quiet = True, n=(bounds + padding + padding), s=0, e=(bounds + padding + padding), w=0, res=sampres)
        grass.run_command("r.null", quiet = True, map=init_sqrs, null=0)
        #initiate and start inner loop for the additive sammpling regime
        for i in range(iters):
            if i + 1 == 1:
                old_sqrs = init_sqrs
            else:
                old_sqrs = new_sqrs
            new_sqrs = "%s_itr%s" % (prefix, str(i + 1).zfill(2))
            grass.mapcalc("${new_sqrs}=eval(a=if(${old_sqrs} > 0 && ${sampdist} > 0, 1, 0), b=if(${old_sqrs}[1,0] == 1 || ${old_sqrs}[0,1] == 1 || ${old_sqrs}[-1,0] == 1 || ${old_sqrs}[0,-1] == 1, 1, 0), c=if(b > 0 && ${sampdist} > 0, 1, a), if(isnull(c),0,c))", quiet = True, overwrite = True, old_sqrs = old_sqrs, new_sqrs = new_sqrs, sampdist = sampdist)
        # rename last map to save it
        outmap = "%s_%s" % (prefix,str(x + 1).zfill(pad))
        grass.run_command("g.rename", quiet = True, raster="%s,%s" % (new_sqrs,outmap))
        # pull some stats
        presab = grass.parse_command("r.stats", quiet = True,flags="cn", input=outmap, separator="=")
        try:
            pres = int(presab['1'])
        except:
            pres = 0
        R = grass.parse_command('r.regression.line', flags='g', mapx=realpresab, mapy=outmap)["R"]
        f.write("%s,%s,%s,%s,%s,%s,%s\n" % (x + 1,pres,truepres,truepres - pres,(truepres - pres)/float(truepres),R, float(R) * float(R)))
        f.flush()
    #clean up
    f.close()
    grass.run_command("g.remove", quiet = True, flags = 'f', type = 'raster', pattern = "*_itr*")
예제 #4
0
파일: v.krige.py 프로젝트: rkrug/grass-ci
    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 get_time_steps():
  indexmaps = grass.parse_command('g.list', type='vect', patt='drainage_basins_??????').keys()
  indexmaps = sorted(indexmaps)[::-1]
  ages = []
  for indexmap in indexmaps:
    ages.append( str(indexmap.split('_')[-1]) )
  return ages
예제 #6
0
    def CompositionMetrics(self):
        '''Overlay landcover with viewshed, calculate visible cover,
        and return percentage of landcover classes in viewshed
        '''
        ## Compute statistics ##
        stat = gscript.parse_command('r.stats',
                                     input=self.out_landuse,
                                     flags='apn',
                                     separator='comma',
                                     overwrite=True)

        cleanDic = {}
        areaList = []
        totarea = 0
        for item in stat.keys():
            cat = int(item.split(",")[0])
            area = item.split(",")[1]
            percent = item.split(",")[2]
            cleanDic[cat] = percent.strip("%").strip("u")
            totarea += float(area)
            print totarea

        areaList = []
        for item in sorted(self.landuse.keys()):
            if item in cleanDic.keys():
                percent = cleanDic[item]
                areaList.append(str(percent))
            else:
                areaList.append("0")
        areaList.append(str(totarea))

        return areaList
예제 #7
0
    def set_region_from_timeseries(self, timeseries):
        """Sets computational region for rendering.

        This function sets the computation region from the extent of
        a space-time dataset by using its bounding box and resolution.

        If user specified the name of saved region during object's initialization,
        the provided region is used. If it's not specified
        and use_region=True, current region is used.
        """
        if self._saved_region:
            self._env["GRASS_REGION"] = gs.region_env(
                region=self._saved_region, env=self._env)
            return
        if self._use_region:
            # use current
            return
        # Get extent, resolution from space time dataset
        info = gs.parse_command("t.info",
                                input=timeseries,
                                flags="g",
                                env=self._env)
        # Set grass region from extent
        self._env["GRASS_REGION"] = gs.region_env(
            n=info["north"],
            s=info["south"],
            e=info["east"],
            w=info["west"],
            nsres=info["nsres_min"],
            ewres=info["ewres_min"],
        )
예제 #8
0
def get_variance(mapname, raster):
    """Calculate intra-segment variance of the values of the given raster"""

    # current_process name contains '-' which can cause problems so we replace
    # with '_'
    temp_map = "isegmentuspo_temp_variance_map_%d_%s" % (
        os.getpid(),
        current_process().name.replace("-", "_"),
    )
    gscript.run_command(
        "r.stats.zonal",
        base=mapname,
        cover=raster,
        method="variance",
        output=temp_map,
        overwrite=True,
        quiet=True,
    )
    univar = gscript.parse_command("r.univar",
                                   map_=temp_map,
                                   flags="g",
                                   quiet=True)
    var = float(univar["mean"])
    gscript.run_command("g.remove",
                        type_="raster",
                        name=temp_map,
                        flags="f",
                        quiet=True)
    return var
예제 #9
0
def citation_for_module(name, add_grass=False):
    """Provide dictionary of citation values for a module"""
    path = documentation_filename(name)

    # derive core strings from lhmpom:
    # NAME / AUTHOR / LAST CHANGED / COPYRIGHT: Years + Entity

    text = open(path).read()

    g_version = gs.parse_command("g.version", flags="g")

    # using default empty value, this way we use just if d['k']
    # to check presence and non-emptiness at the same time
    citation = defaultdict(str)
    citation["module"] = name
    citation["grass-version"] = g_version["version"]
    citation["grass-build-date"] = g_version["build_date"]
    citation["authors"] = get_authors_from_documentation(text)
    citation["year"] = get_year_from_documentation(text)
    code_url, code_history_url = get_code_urls_from_documentation(text)
    citation["code-url"] = code_url
    citation["url-code-history"] = code_history_url

    if add_grass:
        scope = "Use the following to cite the whole GRASS GIS"
        citation["references"] = [grass_cff_reference(g_version, scope=scope)]

    return citation
 def Analyze(self):
     gscript.run_command('i.segment',
                         group=self.group,
                         output=self.segment,
                         threshold=0.3,
                         minsize=50,
                         env=self.env)
     gscript.run_command('r.clump',
                         input=self.segment,
                         output=self.segment_clump,
                         env=self.env)
     gscript.run_command('i.smap',
                         group=self.group,
                         subgroup=self.group,
                         signaturefile=self.signature,
                         output=self.classification,
                         goodness=self.reject,
                         env=self.env)
     percentile = float(
         gscript.parse_command('r.univar',
                               flags='ge',
                               map=self.reject,
                               env=self.env)['percentile_90'])
     gscript.mapcalc(
         '{new} = if({classif} < {thres}, {classif}, null())'.format(
             new=self.filtered_classification,
             classif=self.classification,
             thres=percentile),
         env=self.env)
     gscript.run_command('r.stats.quantile',
                         base=self.segment_clump,
                         cover=self.filtered_classification,
                         output=self.output,
                         env=self.env)
예제 #11
0
    def OnRegression(self, event):
        """Displays regression information in messagebox
        """
        message = []
        title = _('Regression Statistics for Scatterplot(s)')

        for rpair in self.rasterList:
            if isinstance(rpair, tuple) == False: continue
            rast1, rast2 = rpair
            rast1 = rast1.split('@')[0] 
            rast2 = rast2.split('@')[0] 
            ret = grass.parse_command('r.regression.line', 
                                      mapx = rast1, 
                                      mapy = rast2, 
                                      flags = 'g', quiet = True,
                                      parse = (grass.parse_key_val, { 'sep' : '=' }))
            eqtitle = _('Regression equation for raster map <%(rast1)s> vs. <%(rast2)s>:\n\n') % \
                { 'rast1' : rast1,
                  'rast2' : rast2 }
            eq = '   %s = %s + %s(%s)\n\n' % (rast2, ret['a'], ret['b'], rast1)
            num = 'N = %s\n' % ret['N']
            rval = 'R = %s\n' % ret['R']
            rsq = 'R-squared = %f\n' % pow(float(ret['R']), 2)
            ftest = 'F = %s\n' % ret['F']
            str = eqtitle + eq + num + rval + rsq + ftest
            message.append(str)
            
        stats = PlotStatsFrame(self, id = wx.ID_ANY, message = message, 
                                      title = title)

        if stats.Show() == wx.ID_CLOSE:
            stats.Destroy()       
def main():

    # process command options
    input = options['input']
    if not gs.find_file(input)['file']:
        gs.fatal(_("Raster map <%s> not found") % input)

    output = options['output']
    if gs.find_file(output)['file'] and not gs.overwrite():
        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
예제 #13
0
def import_raster(filename, module, args):
    mapname = _map_name(filename)
    gs.message(_("Processing <{}>...").format(mapname))
    if module == "r.import":
        kv = gs.parse_command("g.proj", flags="j")
        if kv["+proj"] == "longlat":
            args["resolution"] = "estimated"
        else:
            args["resolution"] = "value"
            args["resolution_value"] = _raster_resolution(filename)
    try:
        gs.run_command(module, input=filename, output=mapname, **args)
        if gs.raster_info(mapname)["datatype"] in ("FCELL", "DCELL"):
            gs.message("Rounding to integer after reprojection")
            gs.use_temp_region()
            gs.run_command("g.region", raster=mapname)
            gs.run_command(
                "r.mapcalc",
                quiet=True,
                expression="tmp_%s = round(%s)" % (mapname, mapname),
            )
            gs.run_command(
                "g.rename",
                quiet=True,
                overwrite=True,
                raster="tmp_%s,%s" % (mapname, mapname),
            )
            gs.del_temp_region()
        gs.raster_history(mapname)
    except CalledModuleError as e:
        pass  # error already printed
def create_heatmaps(vectors, background_ortho, radius, width, height):
    os.environ['GRASS_FONT'] = '/usr/share/fonts/truetype/freefont/FreeSansBold.ttf'
    names = []
    for vector in vectors:
        gscript.run_command('v.kernel', input=vector, output=vector + '_kernel', radius=radius, overwrite=True, quiet=True)
        names.append(vector + '_kernel')
    gscript.write_command('r.colors', map=names, rules='-', stdin='0% white\n10% yellow\n40% red\n100% magenta')
    maxdens = float(gscript.parse_command('r.univar', map=names, flags='g')['max'])
    for vector in vectors:
        gscript.run_command('d.mon', start='cairo', output='foreground_' + vector + '_kernel' + '.png',
                            width=width, height=height, overwrite=True)
        gscript.run_command('d.rast', map=vector + '_kernel')
        gscript.run_command('d.mon', stop='cairo')
        # background
        gscript.run_command('d.mon', start='cairo', output='background_' + vector + '_kernel' + '.png',
                            width=width, height=height, overwrite=True)
        gscript.run_command('d.rast', map=background_ortho)
        gscript.run_command('d.legend', flags='t', raster=vector + '_kernel', label_step=0.5, digits=1, range=[0, maxdens], at=[3,40,3,6], color='white')
        gscript.run_command('d.mon', stop='cairo')

        # put together with transparency
        foreground = Image.open('foreground_' + vector + '_kernel' + '.png')
        background = Image.open('background_' + vector + '_kernel' + '.png')
        foreground = foreground.convert("RGBA")
        datas = foreground.getdata()
        newData = []
        for item in datas:
            intens = item[0] + item[1] + item[2]
            newData.append((item[0], item[1], item[2], min(765-intens, 200)))
        foreground.putdata(newData)
        background.paste(foreground, (0, 0), foreground)
        background.save('heatmap_{v}.png'.format(v=vector), "PNG")
        gscript.try_remove('foreground_' + vector + '_kernel' + '.png')
        gscript.try_remove('background_' + vector + '_kernel' + '.png')
def main(out,maps,ms,keepdtype,ndv,createopts):
    
    # set mapset
    set_mapset(ms)
    
    # turn categorical names into dummy names
    maps=parse_feature_names(maps)

    # make desired output_mask
    # slopes above 55 degrees masked and points on top of water or snow masked
    make_output_mask('(slope < 55) && (lcc == 2 || lcc == 3)','buffered_basin_border')
    
    # run separately for each map
    for m in maps:
        dtype = gscript.parse_command('r.info',flags='g',map=m)['datatype']

        if dtype == 'CELL':
            export_maps([m],out,'Byte',keepdtype,ndv,createopts)
        else:
            export_maps([m],out,'Float32',keepdtype,ndv,createopts)


    # remove group and mask
    gscript.run_command('g.remove',
                            type='group',
                            name='to_export',
                            quiet=True,
                            flags='f')
    drop_mask()
예제 #16
0
    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
예제 #17
0
def main():
    infile = options['input']
    value = options['value']
    mode = options['mode']
    outfile = options['output']
    global method
    method = options['method']
    clumped = flags['c']
    diagonal = flags['d']

    # check for unsupported locations
    in_proj = grass.parse_command('g.proj', flags='g')
    if in_proj['unit'].lower() == 'degree':
        grass.fatal(_("Latitude-longitude locations are not supported"))
    if in_proj['name'].lower() == 'xy_location_unprojected':
        grass.fatal(_("xy-locations are not supported"))

    # check lesser and greater parameters
    limit = float(value)
    if mode == 'greater' and method == 'rmarea':
        grass.fatal(_("You have to specify mode='lesser' with method='rmarea'"))

    if not grass.find_file(infile)['name']:
        grass.fatal(_("Raster map <%s> not found") % infile)

    if method == 'reclass':
        reclass(infile, outfile, limit, clumped, diagonal, mode == 'lesser')
    elif method == 'rmarea':
        rmarea(infile, outfile, limit, in_proj['meters'])

    grass.message(_("Generating output raster map <%s>...") % outfile)
def main():
    """
    RichDEM flat resolution: give a gentle slope
    """
    # lazy import RICHDEM
    try:
        import richdem as rd
    except:
        g.message(
            flags="e",
            message=("RichDEM not detected. Install pip3 and " +
                     "then type at the command prompt: " +
                     '"pip3 install richdem".'),
        )

    _input = options["input"]
    _output = options["output"]

    # Check for overwrite
    _rasters = np.array(gscript.parse_command("g.list", type="raster").keys())
    if (_rasters == _output).any():
        g.message(flags="e", message="output would overwrite " + _output)

    dem = garray.array(_input, null=np.nan)

    rd_input = rd.rdarray(dem, no_data=np.nan)
    rd_output = rd.ResolveFlats(rd_input)

    dem[:] = rd_output[:]
    dem.write(_output, overwrite=gscript.overwrite())
예제 #19
0
def get_size(vector):
    tmpvector = "tmp_getsize_%s" % str(os.getpid())
    rm_vectors.append(tmpvector)
    grass.run_command("g.copy",
                      vector="%s,%s" % (vector, tmpvector),
                      overwrite=True,
                      quiet=True)
    if len(grass.vector_db(tmpvector)) == 0:
        grass.run_command("v.db.addtable", map=tmpvector, quiet=True)
    grass.run_command("v.db.addcolumn",
                      map=tmpvector,
                      columns="tmparea DOUBLE PRECISION",
                      quiet=True)
    grass.run_command(
        "v.to.db",
        map=tmpvector,
        columns="tmparea",
        option="area",
        units="meters",
        quiet=True,
        overwrite=True,
    )
    sizeselected = grass.parse_command("v.db.select", map=tmpvector, flags="v")
    sizesstr = [
        x.split("|")[1:] for x in sizeselected if x.startswith("tmparea|")
    ][0]
    sizes = [float(x) for x in sizesstr]
    return sum(sizes)
예제 #20
0
def get_size(vector):
    tmpvector = 'tmp_getsize_%s' % str(os.getpid())
    rm_vectors.append(tmpvector)
    grass.run_command('g.copy',
                      vector="%s,%s" % (vector, tmpvector),
                      quiet=True)
    if len(grass.vector_db(tmpvector)) == 0:
        grass.run_command('v.db.addtable', map=tmpvector, quiet=True)
    grass.run_command('v.db.addcolumn',
                      map=tmpvector,
                      columns="tmparea DOUBLE PRECISION",
                      quiet=True)
    grass.run_command('v.to.db',
                      map=tmpvector,
                      columns='tmparea',
                      option='area',
                      units='meters',
                      quiet=True,
                      overwrite=True)
    sizeselected = grass.parse_command('v.db.select', map=tmpvector, flags="v")
    sizesstr = [
        x.split('|')[1:] for x in sizeselected if x.startswith('tmparea|')
    ][0]
    sizes = [float(x) for x in sizesstr]
    return sum(sizes)
예제 #21
0
def preprocess(reflbandnames, panbandnames, dataset, outputraster, scene):
    options, flags = grass.parser()
    pansuffix = ['red', 'green', 'blue']
    print os.environ
    importregex = re.compile('.*[.]TIF')

    counter = 1
    for file in os.listdir(dataset):
        if re.search(importregex, file):
            if len(file) == 29:
                num = file[23] + file[24]
            else:
                num = file[23]
            read2_command('r.external', input=dataset + '/' + file, output='B' + num, overwrite=True, flags='e')
        counter = counter + 1

    for file in os.listdir(dataset):
        if fnmatch.fnmatch(file, '*.txt'):
            mtl = file
    metfile = os.path.join(dataset, mtl)

    read2_command('i.landsat.toar', input='B', output='B_refl', metfile=metfile, sensor='oli8', overwrite=True)
    print('reflectance calculated')

    read2_command('r.colors', map=reflbandnames, flags='e', color='grey')
    print('histograms equalized')

    read2_command('i.colors.enhance', red=reflbandnames[0], green=reflbandnames[1], blue=reflbandnames[2])
    print('colors enhanced')


    # pansharpen
    read2_command('i.fusion.brovey', ms3=reflbandnames[0], ms2=reflbandnames[1], ms1=reflbandnames[2],
                      pan=panbandnames[3], overwrite=True, flags='l', output_prefix='brov')
    pannames = ['brov.' + s for s in pansuffix]
    pannames255 = [s + '_255' for s in pannames]
    print('pansharpening and composition achieved')
    read2_command('g.region', raster=pannames)
    read2_command('r.colors', map=pannames, flags='e', color='grey')
    for raster in pannames:
        minmax = grass.parse_command('r.info', map=raster, flags='r')
        print(minmax)
        newrast = raster + '_255'
        grass.write_command('r.recode', input=raster, output=newrast, rules='-',
                            stdin=minmax[u'min'] + ':' + minmax[u'max'] + ':0:255',
                            overwrite=True)
    print('rasters recoded to CELL type')
    # equalize colors once again
    read2_command('r.colors', map=[pannames255[0], pannames255[1], pannames255[2]], flags='e', color='grey')
    read2_command('i.colors.enhance', red=pannames255[0], green=pannames255[1], blue=pannames255[2])
    #read2_command('r.composite', red=pannames[0], green=pannames[1], blue=pannames[2], output='comp',
    #                 overwrite=True)

    # create imagery group
    read2_command('i.group', group='pangroup876', subgroup='pangroup876', input=pannames255)
    print('created imagery group')

    read2_command('r.out.gdal', input='pangroup876', output=outputraster,
                  overwrite=True, format='GTiff', type='Int32', flags='f')
예제 #22
0
def main():
    vector = options['input']
    output = options['output']
    # JL Handling Invalid transect_spacing parameter
    try:
        transect_spacing = float(options['transect_spacing'])
    except:
        grass.fatal(_("Invalid transect_spacing value."))
    if transect_spacing == 0.0:
        grass.fatal(_("Zero invalid transect_spacing value."))
    dleft = options['dleft']
    dright = options['dright']
    shape = options['type']
    print dleft, transect_spacing
    if not dleft:
        dleft = transect_spacing
    else:
        # JL Handling Invalid dleft parameter
        try:
            dleft = float(dleft)
        except:
            grass.fatal(_("Invalid dleft value."))
    if not dright:
        dright = transect_spacing
    else:
        # JL Handling Invalid dright parameter
        try:
            dright = float(dright)
        except:
            grass.fatal(_("Invalid dright value."))
    # check if input file does not exists
    if not grass.find_file(vector, element='vector')['file']:
        grass.fatal(_("<%s> does not exist.") % vector)
    # check if output file exists
    if grass.find_file(output,
                       element='vector')['mapset'] == grass.gisenv()['MAPSET']:
        if not grass.overwrite():
            grass.fatal(_("output map <%s> exists") % output)

    #JL Is the vector a line and does if have at least one feature?
    info = grass.parse_command('v.info', flags='t', map=vector)
    if info['lines'] == '0':
        grass.fatal(_("vector <%s> does not contain lines") % vector)

    #################################
    v = loadVector(vector)
    transect_locs = get_transects_locs(v, transect_spacing)
    temp_map = tempmap()
    if shape == 'line' or not shape:
        transect_ends = get_transect_ends(transect_locs, dleft, dright)
        writeTransects(transect_ends, temp_map)
    elif shape == 'area':
        transect_ends = get_transect_ends(transect_locs, dleft, dright)
        writeQuads(transect_ends, temp_map)
    else:
        writePoints(transect_locs, temp_map)

    grass.run_command('v.category', input=temp_map, output=output, type=shape)
    grass.run_command('g.remove', vect=temp_map)
def get_time_steps():
  indexmaps = grass.parse_command('g.list', type='vect', patt='drainage_basins_??????').keys()
  indexmaps = sorted(indexmaps)[::-1]
  ages = []
  for indexmap in indexmaps:
    ages.append( str(indexmap.split('_')[-1]) )
  #ages = ages[-25:] # TEMPORARY HACK-EY TO FINISH G12
  return ages
예제 #24
0
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."
            )

    projunits = str(projinfo["units"])  # Unicode to str
    # Then compute
    if (projunits == "meters") or (projunits == "Meters"):
        if units == "m2":
            grass.mapcalc(output + " = nsres() * ewres()")
        elif units == "km2":
            grass.mapcalc(output + " = nsres() * ewres() / 10.^6")
    elif (projunits == "degrees") or (projunits == "Degrees"):
        if units == "m2":
            grass.mapcalc(
                output
                + " = ( 111195. * nsres() ) * \
                          ( ewres() * "
                + str(np.pi / 180.0)
                + " * 6371000. * cos(y()) )"
            )
        elif units == "km2":
            grass.mapcalc(
                output
                + " = ( 111.195 * nsres() ) * \
                          ( ewres() * "
                + str(np.pi / 180.0)
                + " * 6371. * cos(y()) )"
            )
    else:
        print("Units: ", projunits, " not currently supported")
예제 #25
0
def render_2d(envs):

    # set rendering parameters
    brighten = 0  # percent brightness of shaded relief
    render_multiplier = 1  # multiplier for rendering size
    whitespace = 1.5
    fontsize = 36 * render_multiplier  # legend font size
    legend_coord = (10, 50, 1, 4)  # legend display coordinates
    zscale = 1

    # create rendering directory
    render = os.path.join(gisdbase, location, 'rendering')
    if not os.path.exists(render):
        os.makedirs(render)

    for mapset in simulations:

        # change mapset
        gscript.read_command('g.mapset', mapset=mapset, location=location)
        info = gscript.parse_command('r.info', map='elevation', flags='g')
        width = int(info.cols) * render_multiplier * whitespace
        height = int(info.rows) * render_multiplier

        # render net difference
        gscript.run_command('d.mon',
                            start=driver,
                            width=width,
                            height=height,
                            output=os.path.join(
                                render,
                                mapset + '_' + 'net_difference' + '.png'),
                            overwrite=1)
        gscript.write_command('r.colors',
                              map='net_difference',
                              rules='-',
                              stdin=difference_colors)
        gscript.run_command('r.relief',
                            input='elevation',
                            output='relief',
                            altitude=90,
                            azimuth=45,
                            zscale=zscale,
                            env=envs[mapset])
        gscript.run_command('d.shade',
                            shade='relief',
                            color='net_difference',
                            brighten=brighten)
        gscript.run_command('d.legend',
                            raster='net_difference',
                            fontsize=fontsize,
                            at=legend_coord)
        gscript.run_command('d.mon', stop=driver)

        try:
            # stop cairo monitor
            gscript.run_command('d.mon', stop=driver)
        except CalledModuleError:
            pass
예제 #26
0
def get_autocorrelation(mapname, raster, neighbordict, method):
    """Calculate either Moran's I or Geary's C for values of the given raster"""

    raster_vars = gscript.parse_command("r.univar",
                                        map_=raster,
                                        flags="g",
                                        quiet=True)
    global_mean = float(raster_vars["mean"])

    univar_res = gscript.read_command(
        "r.univar",
        flags="t",
        map_=raster,
        zones=mapname,
        out="-",
        sep="comma",
        quiet=True,
    )

    means = {}
    mean_diffs = {}
    firstline = True
    for line in univar_res.splitlines():
        l = line.split(",")
        if firstline:
            i = l.index("mean")
            firstline = False
        else:
            means[l[0]] = float(l[i])
            mean_diffs[l[0]] = float(l[i]) - global_mean

    sum_sq_mean_diffs = sum(x**2 for x in mean_diffs.values())

    total_nb_neighbors = 0
    for region in neighbordict:
        total_nb_neighbors += len(neighbordict[region])

    N = len(means)
    sum_products = 0
    sum_squared_differences = 0
    for region in neighbordict:
        region_value = means[region] - global_mean
        neighbors = neighbordict[region]
        nb_neighbors = len(neighbors)
        for neighbor in neighbors:
            neighbor_value = means[neighbor] - global_mean
            sum_products += region_value * neighbor_value
            sum_squared_differences = (means[region] - means[neighbor])**2

    if method == "moran":
        autocor = (float(N) / total_nb_neighbors) * (float(sum_products) /
                                                     sum_sq_mean_diffs)
    elif method == "geary":
        autocor = (float(N - 1) / (2 * total_nb_neighbors)) * (
            float(sum_squared_differences) / sum_sq_mean_diffs)

    return autocor
예제 #27
0
def comp_rasters(directory, cleanup=False, png=False):
    for item in os.listdir(directory):
        path = os.path.join(directory, item)
        if not os.path.isdir(path) or path.endswith('gdb'):
            continue
        ds = gdal.Open(path)
        if ds is None:
            continue

        # blacklist
        if item in ['fl_dir']:
            continue

        # link arcgis raster to GRASS
        arcgis = '{}_arcgis'.format(item)
        gs.run_command('r.external',
                       input=path, output=arcgis, flags='o'
        )
        gs.run_command('r.colors',
                       map=arcgis, raster=item
        )

        gs.run_command('g.region',
                       raster=item
        )
        diff = '{}_diff'.format(item)
        gs.run_command('r.mapcalc',
                       expression='{} = {} - {}'.format(diff, arcgis, item)
        )
        gs.run_command('r.colors',
                       map=diff, color='diff'
        )
        if png:
            gs.run_command('d.mon',
                           start='cairo', output=os.path.join(OUTPUT, '{}.png'.format(item))
            )
            gs.run_command('d.rast.leg',
                           map=diff
            )
            gs.run_command('d.mon',
                           stop='cairo'
            )
        print('{sep}{nl}{map}{nl}{sep}{nl}'.format(sep='-' * 80, nl=os.linesep, map=item))
        stats = gs.parse_command('r.univar',
                                 flags='g',
                                 map=diff
        )
        for key in ('min', 'max', 'range', 'mean'):
            print ('{}={}'.format(key, stats[key]))
        if abs(float(stats['mean'])) < 1e-4:
            print ("-> OK")
        else:
            print ("-> KO")
        if cleanup:
            gs.run_command('g.remove',
                           type='raster', name=','.join(arcgis, diff), flags='f'
            )
 def get_maxim_value(self):
     '''
     Getting the maximum patch size of the map
     
     This is not working for some reason, but the overall script is working
     '''
     
     stats = grass.parse_command('r.univar', map=self.patch_map, flags='g')
     self.raster_max = int(stats['max'])
예제 #29
0
def reg_2deg(input = '', size = 2):

    # get region center
    reg = grass.parse_command('g.region', input = input, flags = 'c')
    lat = float()
    lon = float()

    g.region(n = lat + size/2, s = lat - size/2, w = lon - size/2, e = lon + size/2,
        align = input, flags = 'ap')
예제 #30
0
def main():

    # Get the options
    _input = options["input"]
    output = options["output"]
    expression = options["expression"]
    base = options["basename"]
    method = options["method"]
    nprocs = int(options["nprocs"])
    register_null = flags["n"]
    spatial = flags["s"]

    new_flags = ""
    if register_null:
        new_flags = "n"
    if spatial:
        new_flags = new_flags + "s"

    # get list of bands available in the input strds
    t_info = grass.parse_command('t.info', input=_input, flags='g')
    input_bands = t_info["semantic_labels"].split(',')

    nbands = len(input_bands)

    # find needed bands in formula: if "data[0]" in formula:
    # go through the list of bands and replace (str.replace(old, new)
    # in the formula e.g. data[0] with (input_strds + '.' + bandref[0])
    counter = 0
    new_inputs = []
    band_used = [False for i in range(nbands)]
    while counter < nbands:
        fstr = "data[" + str(counter) + "]"
        bandname = input_bands[counter]
        data_band = ("data.%s") % (bandname)
        if fstr in expression:
            band_used[counter] = True
            newstr = ("%s.%s") % (_input, bandname)
            new_inputs.append(newstr)
            expression = expression.replace(fstr, newstr)
        elif data_band in expression:
            band_used[counter] = True
            newstr = ("%s.%s") % (_input, bandname)
            new_inputs.append(newstr)
            expression = expression.replace(data_band, newstr)
        else:
            band_used[counter] = False
        counter = counter + 1
    # print(expression)

    grass.run_command('t.rast.mapcalc',
                      inputs=(',').join(new_inputs),
                      expression=expression,
                      method=method,
                      output=output,
                      basename=base,
                      nprocs=nprocs,
                      flags=new_flags)
예제 #31
0
def run_view(scanned_elev, blender_path, env, **kwargs):
    # regression
    group = 'color'
    before = 'scan_saved'
    elev_threshold = 20
    color_threshold = 150
    dist_threshold = 30
    change = 'change'
    arrow = 'arrow'
    arrow3d = 'arrow3d'
    arrow_final = 'arrow_final'

    ff = gscript.find_file(name=arrow_final, element='vector')
    old_points = []
    if ff and ff['fullname']:
        old_p = gscript.read_command('v.out.ascii', input=ff['fullname'], format='standard', type='line', env=env).strip().splitlines()
        for op in old_p:
            line = op.strip().split()
            if line == ['1', '1']:
                continue
            try:
                x = float(line[0])
                y = float(line[1])
                z = float(line[2])
                old_points.append((x, y, z))
            except ValueError:
                continue
            except IndexError as e:
                print (line)
                print (e)
                continue
    
    reg_params = gscript.parse_command('r.regression.line', flags='g', mapx=before, mapy=scanned_elev, env=env)
    gscript.mapcalc(exp='{new} = if(({a} + {b} * {after}) - {before} > {thr}, 1, null())'.format(a=reg_params['a'],
                    b=reg_params['b'], after=scanned_elev, before=before, thr=elev_threshold, new=change), env=env)
    #gscript.parse_command('r.univar', map=[group + '_r', group + '_g', group + '_b'], output=, flags='t', zones=, env=env)
    gscript.mapcalc(exp='{new} = if({change} && ({r} + {g} + {b}) / 3. >= {th}, 1, 2)'.format(new=arrow, change=change, th=color_threshold,
                    r=group + '_r', g=group + '_g', b=group + '_b'), env=env)
    gscript.run_command('r.volume', input=arrow, clump=arrow, centroids=arrow, env=env)
    gscript.run_command('v.drape', input=arrow, output=arrow3d, elevation=before, method='bilinear', env=env)
    points = gscript.read_command('v.out.ascii', input=arrow3d, env=env).strip()

    if points:
        new_points = []
        linetext = 'L 2 1\n' 
        for p in points.splitlines():
            x, y, z, c = p.split('|')
            new_points.append((float(x), float(y), float(z)))
            linetext += '{} {} {}\n'.format(x, y, z)
        linetext += '1 1\n'

        # compare old and new
        if not old_points or (dist(old_points[0], new_points[0]) > dist_threshold or dist(old_points[1], new_points[1]) > dist_threshold):
            print ('write')
            gscript.write_command('v.in.ascii', stdin=linetext, input='-', output=arrow_final, format='standard', flags='zn', env=env)
            blender_export_vector(vector=arrow_final, name='vantage', z=True, vtype='line', path=blender_path, time_suffix=False, env=env)
def total_light_index(ntl_image):
    """
    Evaluation index (TLI) which represents the sum of grey values in an area.
    """
    univar = grass.parse_command("r.univar",
                                 map=ntl_image,
                                 flags='g',
                                 parse=(grass.parse_key_val,
                                {'sep': '='}))
    return float(univar['sum'])
예제 #33
0
    def epsg_location(request, response):
        """Check whether the EPSG of a mapset corresponds the specified one."""
        from grass.script import parse_command

        g_proj = parse_command('g.proj', flags='g')

        assert g_proj['epsg'] == '5514', \
            'Error in creating a GRASS location based on an EPSG code'

        return response
예제 #34
0
    def file_location(request, response):
        """Check whether the datum of a mapset corresponds the file one."""
        from grass.script import parse_command

        g_proj = parse_command('g.proj', flags='g')

        assert g_proj['datum'] == 'wgs84', \
            'Error in creating a GRASS location based on a file'

        return response
예제 #35
0
def isExists(FeatNam,FeatType):
	# 'Delete temporal objects.'
	result = False
	vlist = dict.keys(g.parse_command('db.tables',flags='p'))
	for i in range(len(vlist)):
		# Delete the final result if exists.
		if vlist[i] == 'public.'+ str(FeatNam):
			result = True
			print(result)
	return(result)
    def Calibrate(self, event):
        res = gscript.parse_command('r.in.kinect', flags='c', overwrite=True)
        if not (res['calib_matrix'] and len(res['calib_matrix'].split(',')) == 9):
            gscript.message(_("Failed to calibrate"))
            return
        self.settings['tangible']['calibration']['matrix'] = res['calib_matrix']
        UserSettings.SaveToFile(self.settings)

        # update
        self.calib_matrix = res['calib_matrix']
예제 #37
0
    def rusle(self):
        """!main method in rusle_base
        controlling the whole process, once called by main()

        @return soillossbare name of output raster map
        """

        flowacc = outprefix + "flowacc"
        slope = outprefix + "slope"
        lsfactor = outprefix + "lsfactor"

        self.tmp_rast.append(flowacc)
        self.tmp_rast.append(slope)
        self.tmp_rast.append(lsfactor)

        global fieldblock
        if not fieldblock:
            if fieldblockvect:
                fieldblock = outprefix + "fieldblock"
                g.run_command(
                    "v.to.rast",
                    input=fieldblockvect,
                    output=fieldblock,
                    use="val",
                    value="1",
                    quiet=quiet,
                )
        if fieldblock:
            g.verbose('Raster map fieldblock is in "%s"' % fieldblock)
        else:
            fieldblock = ""

        if not options["flowacc"]:
            self._getFlowacc(elevation, flowacc, fieldblock)
            g.verbose('Raster map flowacc is in "%s".' % flowacc)
        else:
            g.verbose('Raster map flowacc taken from "%s".' % flowacc)

        self._getSlope(elevation, slope)
        g.verbose('Raster map slope is in  "%s"' % slope)

        self._getLsfac(flowacc, slope, lsfactor)
        g.verbose('Raster map lsfactor is in  "%s"' % lsfactor)

        self._getSoillossbare(lsfactor, kfactor, rfactor, soillossbare)
        g.message('Soilloss for bare soil in map "%s".' % soillossbare)

        stats = g.parse_command("r.univar",
                                flags="g",
                                map=soillossbare,
                                delimiter="=")
        g.message("mean = %s \n stddev = %s \n min = %s \n max = %s" %
                  (stats["mean"], stats["stddev"], stats["min"], stats["max"]))

        return soillossbare
예제 #38
0
def get_autocorrelation(mapname, raster, neighbordict, indicator):
    """ Calculate either Moran's I or Geary's C for values of the given raster """

    raster_vars = gscript.parse_command('r.univar',
                                        map_=raster,
                                        flags='g',
                                        quiet=True)
    global_mean = float(raster_vars['mean'])

    univar_res = gscript.read_command('r.univar',
                                      flags='t',
                                      map_=raster,
                                      zones=mapname,
                                      out='-',
                                      sep='comma',
                                      quiet=True)

    means = {}
    mean_diffs = {}
    firstline = True
    for line in univar_res.splitlines():
        l = line.split(',')
        if firstline:
            i = l.index('mean')
            firstline = False
        else:
            means[l[0]] = float(l[i])
            mean_diffs[l[0]] = float(l[i]) - global_mean

    sum_sq_mean_diffs = sum(x**2 for x in mean_diffs.values())

    total_nb_neighbors = 0
    for region in neighbordict:
        total_nb_neighbors += len(neighbordict[region])

    N = len(means)
    sum_products = 0
    sum_squared_differences = 0
    for region in neighbordict:
        region_value = means[region] - global_mean
        neighbors = neighbordict[region]
        nb_neighbors = len(neighbors)
        for neighbor in neighbors:
            neighbor_value = means[neighbor] - global_mean
            sum_products += region_value * neighbor_value
            sum_squared_differences = (means[region] - means[neighbor])**2

    if indicator == 'morans':
        autocor = ((float(N) / total_nb_neighbors) *
                   (float(sum_products) / sum_sq_mean_diffs))
    elif indicator == 'geary':
        autocor = (float(N - 1) / (2 * total_nb_neighbors)) * \
            (float(sum_squared_differences) / sum_sq_mean_diffs)

    return autocor
예제 #39
0
def get_aoi(vector=None):
    args = {}
    if vector:
        args['input'] = vector

    if gs.vector_info_topo(vector)['areas'] <= 0:
        gs.fatal(_("No areas found in AOI map <{}>...").format(vector))
    elif gs.vector_info_topo(vector)['areas'] > 1:
        gs.warning(_("More than one area found in AOI map <{}>. \
                      Using only the first area...").format(vector))

    # are we in LatLong location?
    s = gs.read_command("g.proj", flags='j')
    kv = gs.parse_key_val(s)
    if '+proj' not in kv:
        gs.fatal(_("Unable to get AOI: unprojected location not supported"))
    geom_dict = gs.parse_command('v.out.ascii', format='wkt', **args)
    num_vertices = len(str(geom_dict.keys()).split(','))
    geom = [key for key in geom_dict][0]
    if kv['+proj'] != 'longlat':
        gs.message(_("Generating WKT from AOI map ({} vertices)...").format(num_vertices))
        if num_vertices > 500:
            gs.fatal(_("AOI map has too many vertices to be sent via HTTP GET (sentinelsat). \
                        Use 'v.generalize' to simplify the boundaries"))
        coords = geom.replace('POLYGON((', '').replace('))', '').split(', ')
        poly = 'POLYGON(('
        poly_coords = []
        for coord in coords:
            coord_latlon = gs.parse_command(
                'm.proj', coordinates=coord.replace(' ', ','), flags='od')
            for key in coord_latlon:
                poly_coords.append((' ').join(key.split('|')[0:2]))
        poly += (', ').join(poly_coords) + '))'
        # Note: poly must be < 2000 chars incl. sentinelsat request (see RFC 2616 HTTP/1.1)
        if len(poly) > 1850:
            gs.fatal(_("AOI map has too many vertices to be sent via HTTP GET (sentinelsat). \
                        Use 'v.generalize' to simplify the boundaries"))
        else:
            gs.message(_("Sending WKT from AOI map to ESA..."))
        return poly
    else:
        return geom
예제 #40
0
def test_patching_backend(tmp_path, patch_backend):
    """Check patching backend works"""
    location = "test"
    gs.core._create_location_xy(tmp_path, location)  # pylint: disable=protected-access
    with grass_setup.init(tmp_path / location):
        gs.run_command("g.region", s=0, n=50, w=0, e=50, res=1)

        points = "points"
        reference = "reference"
        gs.run_command("v.random", output=points, npoints=100)
        gs.run_command("v.to.rast",
                       input=points,
                       output=reference,
                       type="point",
                       use="cat")

        def run_grid_module():
            # modules/shortcuts calls get_commands which requires GISBASE.
            # pylint: disable=import-outside-toplevel
            from grass.pygrass.modules.grid import GridModule

            grid = GridModule(
                "v.to.rast",
                width=10,
                height=5,
                overlap=0,
                patch_backend=patch_backend,
                processes=max_processes(),
                input=points,
                output="output",
                type="point",
                use="cat",
            )
            grid.run()

        run_in_subprocess(run_grid_module)

        mean_ref = float(
            gs.parse_command("r.univar", map=reference, flags="g")["mean"])
        mean = float(
            gs.parse_command("r.univar", map="output", flags="g")["mean"])
        assert abs(mean - mean_ref) < 0.0001
예제 #41
0
def getValOnBuffer(inmap,elev,dist,output,user="",password=""):
	# get number of points
	n = getPointsNum(inmap)
	g.run_command('v.db.addcol', map=outmap, columns='pix_vals double array', quiet=True)
	#g.run_command('v.db.addcol', map=outmap, columns='fft_real double array', quiet=True)
	#g.run_command('v.db.addcol', map=outmap, columns='fft_imgn double array', quiet=True)
	# Connect to db server
	dbinfo = getDbInfo()
	dbname=dbinfo['dbname']
	driver=dbinfo['driver']
	conn = ppg.connect("dbname='"+str(dbname)+"' user='******' host='"+str(host)+"' password='******'")
	cur = conn.cursor()
	for i in range(n-1):
		print "Now processing:" + str(i+1) +":" + nams.keys()[i]
		# extract one feature from points set with cat value.
		g.run_command("v.extract",input=inmap,output="tmp",type="point",new=-1,list=i+1,quiet=True,overwrite=True)
		# create buffer of the extracted point
		g.run_command("v.buffer",input="tmp",output="tmp2",type="point",distance=dist,quiet=True,overwrite=True)
		# add attributes table and new a column storing value for the buffer object.
		g.run_command("v.db.addtable",map="tmp2",columns="val double precision",quiet=True)
		# set default value as 1.
		g.run_command("v.db.update",map="tmp2",column="val",value=1,quiet=True)
		# Redefine geographic region for procedure.
		g.run_command("g.region",vect="tmp2",quiet=True)   
		# convert vector map buffer to raster map buffer.
		g.run_command("v.to.rast",input="tmp2",output="tmprast",col="val",overwrite=True,quiet=True)
		# get elevation on the raster buffer.
		g.run_command("r.mapcalculator",amap="tmprast",bmap=elev,formula="A*B",outfile="tmprast2",overwrite=True,quiet=True)    
		nam = i+1
		pix = g.parse_command("r.stats",flags="1",input="tmprast2",nv="",fs=",",quiet=True)
		res = 'ARRAY['
		for j in pix.keys():
			res = res + str(j) + ','
		res = res + ']'
		# Update the column
		sql='UPDATE '+str(inmap)+' SET pix_vals = '+str(pix_vals)+' WHERE cat = '+str(i+1)
		cur.execute(sql)
		# Remove temporal features
		g.parse_command("g.remove",vect="tmp,tmp2",rast="tmprast,tmprast2",quiet=True)
		# Set region with DEM.
		g.parse_command("g.region",rast=elv,quiet=True)
	conn.close()
def Data_prep(Land_cover):
    '''
	Function that extracts informations from the Land Cover : resolution and classes
	'''

    info = gscript.raster_info(Land_cover)
    nsres = info.nsres
    ewres = info.ewres
    L = []
    L = [cl for cl in gscript.parse_command('r.category', map=Land_cover)]
    return nsres, ewres, L
예제 #43
0
def D_index(n1, n2, v1, v2, txtf):
    """Calculate D (Schoener's 1968)"""
    tmpf0 = tmpname("rniche")
    gs.mapcalc("$tmpf0 = abs(double($n1)/$v1 - double($n2)/$v2)",
               tmpf0=tmpf0, n1=n1, v1=v1, n2=n2, v2=v2, quiet=True)
    NO = float(gs.parse_command("r.univar", quiet=True, flags="g",
                                map=tmpf0)['sum'])
    NOV = 1 - (0.5 * NO)
    gs.info(_("Niche overlap (D) of {} and {} {}").format(n1.split('@')[0],
            n2.split('@')[0], round(NOV, 3)))
    return ['Niche overlap (D)', n1, n2, NOV]
예제 #44
0
    def mkstreams(self):
        '''Create minimal stream network reaching all subbasins and with nice main streams'''
        # get max accumulation and cell count for each subbasin
        rsmaxaccum = gread('r.stats', input='maxaccum__', flags='lcn')
        rsmaxaccum = np.array(rsmaxaccum.split(), dtype=float).reshape((-1, 3)).astype(int)
        subbasinIDs = rsmaxaccum[:, 0]
        maxaccum = rsmaxaccum[:, 1]
        # cellcounts must not be larger than maxaccum (may happen in subbasins with more than 1 outlet)
        cellcounts = np.min([rsmaxaccum[:, 2], maxaccum], axis=0)
        # calculate optima accumulation for nice headwater mainstreams
        accr = grass.parse_command('r.info', map=self.accumulation, flags='g')
        minaccum = np.int32(round(float(self.minmainstreams)*1e6 /
                            (float(accr['nsres'])*float(accr['ewres']))))
        minaccum = np.ones_like(maxaccum) * minaccum
        optiaccum   = np.min([maxaccum-np.int32(cellcounts*0.1), minaccum], axis=0)
        # check incoming subbasins maxaccum and take the smallest accumulation to update optiaccum
        subnext     = readSubNxtID(self.outlets)
        optiaccum   = dict(zip(subbasinIDs,optiaccum))
        maxaccum    = dict(zip(subbasinIDs,maxaccum))
        for sn in np.unique(subnext['nextID']):
            if sn < 0: continue
            for sb in subnext[subnext['nextID']==sn]['subbasinID']:
                optiaccum[sn] = min(optiaccum[sn],maxaccum[sb]-1)
        # make raster
        tempf = grass.tempfile()
        np.savetxt(tempf,optiaccum.items(),fmt='%i=%i')
        grass.run_command('r.reclass',input='maxaccum__',output='optiaccum__',
                          rules=tempf,quiet=True)
        # get accumulation and make lines
        grass.mapcalc("{0}__unthin=if({1} > {2},{1},null())".format(self.mainstreams,
                      self.accumulation,'optiaccum__'),overwrite=True)

        # make sure all pixels between outlets and inlets are included
        #grun('v.to.rast',input=self.outletinletlines,output='routingnet__rast',
        #     use='val',type='line',quiet=True)
        #grass.mapcalc("{0}=if(isnull({0})&~isnull({1}),{2},{0})".format(self.mainstreams,
        #              'routingnet__rast',self.accumulation),overwrite=True)
        grun('r.thin', input=self.mainstreams+'__unthin', output=self.mainstreams, overwrite=True, quiet=True) # may exclude outlet/inlet points

        # use predefined streams for subbasins that have them
        if 'streams' in self.options:
            grun('v.to.rast',input=self.streams,output='stream__rast',
             use='val',type='line',val=1,quiet=True)
            grun('r.thin', input='stream__rast', output='stream__rast__thin',
                 overwrite=True, quiet=True)
            grun('r.stats.zonal',base=self.subbasinrast,cover='stream__rast__thin',
                 method='sum',output='n__streams__subbasins',quiet=True,overwrite=True)
            # get subbasins that have at least x cells of streams
            grass.mapcalc('{0}=if(n__streams__subbasins>10,{1},{0})'.format(self.mainstreams,'stream__rast__thin'),
                            overwrite=True)
        # make final vector
        grun('r.to.vect', input=self.mainstreams, output=self.mainstreams,
             type='line',quiet=True)
        return
예제 #45
0
def header(fd):
    import grass.script.core as grass
    fd.write('<?xml version="1.0" encoding="UTF-8"?>\n')
    fd.write('<!DOCTYPE task SYSTEM "grass-addons.dtd">\n') # TODO
    # doesn't work in GRASS 6
    # vInfo = grass.version()
    vInfo = grass.parse_command('g.version', flags='g')
    fd.write('<addons version="%s" revision="%s" date="%s">\n' % \
                 (vInfo['version'].split('.')[0],
                  vInfo['revision'],
                  datetime.now()))
예제 #46
0
	def getQu(FeatNam,colname):   
	# get Calculated Values from the Feature table.
	dt = g.parse_command('v.db.select',flags='c', map=FeatNam ,columns=colname)
	dist = []
	n=len(dt)
	for i in range(n-1):
		dist=dist + [float(dict.keys(dt)[i])]
	# calculate quantile of distance to the nearest point.
	r_dist = ro.FloatVector(dist)
	r_summ = r_base.summary(r_dist)
	return(r_summ)
	dt = g.parse_command('v.db.select',flags='c', map=FeatNam ,columns=colname)
	dist = []
	n=len(dt)
	for i in range(n-1):
		dist=dist + [float(dict.keys(dt)[i])]
	# calculate quantile of distance to the nearest point.
	r_dist = ro.FloatVector(dist)
	r_summ = r_base.summary(r_dist)
	return(r_summ)
예제 #47
0
def render_2d(envs):

    brighten = 0  # percent brightness of shaded relief
    render_multiplier = 1  # multiplier for rendering size
    whitespace = 1.5 # canvas width relative to map for legend
    fontsize = 36 * render_multiplier  # legend font size
    legend_coord = (5, 45, 2, 5)  # legend display coordinates
    zscale = 1 # vertical exaggeration

    # create rendering directory
    render = os.path.join(gisdbase, location, 'rendering')
    if not os.path.exists(render):
        os.makedirs(render)

    for mapset in simulations:

        # change mapset
        gscript.read_command('g.mapset',
            mapset=mapset,
            location=location)

        # set region
        gscript.run_command('g.region', rast=region, res=res)

        # set render size
        info = gscript.parse_command('r.info',
            map='elevation',
            flags='g')
        width = int(info.cols)*render_multiplier*whitespace
        height = int(info.rows)*render_multiplier

        # render net difference
        gscript.run_command('d.mon',
            start=driver,
            width=width,
            height=height,
            output=os.path.join(render, mapset+'_'+'net_difference'+'.png'),
            overwrite=1)
        gscript.run_command('r.relief',
            input='elevation',
            output='relief',
            altitude=90,
            azimuth=45,
            zscale=zscale,
            env=envs[mapset])
        gscript.run_command('d.shade',
            shade='relief',
            color='net_difference',
            brighten=brighten)
        gscript.run_command('d.legend',
            raster='net_difference',
            fontsize=fontsize,
            at=legend_coord)
        gscript.run_command('d.mon', stop=driver)
def parse_feature_names(maps):
    """Expand all categorical variable raster names into dummy variable raster names"""
    # take the dummy variable maps, not the categorical
    result = maps
    
    for i in ['lcc','feature']:
        if i in maps:
            dummies = gscript.parse_command('g.list',
                                           type='rast',
                                           pattern='{}_*'.format(i)).keys()
            result.remove(i)
            result += dummies
    return result
예제 #49
0
    def rusle(self):
        """!main method in rusle_base
        controlling the whole process, once called by main()

        @return soillossbare name of output raster map
        """

        flowacc = outprefix + 'flowacc'
        slope  =  outprefix + 'slope'
        lsfactor = outprefix+ 'lsfactor'
        #self.tmp_rast.append(flowacc)
        #self.tmp_rast.append(slope)
        #self.tmp_rast.append(lsfactor)

        global fieldblock
        if not fieldblock:
            if fieldblockvect:
                fieldblock = outprefix + "fieldblock"
                gscript.run_command("v.to.rast",
                        input=fieldblockvect,
                        output= fieldblock,
                        use="val",
                        value="1",
                        quiet=quiet
                        )
        if fieldblock:
            gscript.verbose('Raster map fieldblock is in "%s"'%fieldblock)
        else: fieldblock = ""


        if not options['flowacc']:
            self._getFlowacc(elevation,flowacc,fieldblock)
            gscript.verbose('Raster map flowacc is in "%s".'%flowacc)
        else:
            gscript.verbose('Raster map flowacc taken from "%s".'%flowacc)


        self._getSlope(elevation,slope)
        gscript.verbose('Raster map slope is in  "%s"'%slope)

        self._getLsfac(flowacc,slope,lsfactor)
        gscript.verbose('Raster map lsfactor is in  "%s"'%lsfactor)

        self._getSoillossbare(lsfactor,kfactor,rfactor,soillossbare)
        gscript.message('Soilloss for bare soil in map "%s".' %soillossbare)

        stats = gscript.parse_command('r.univar', flags="g", map=soillossbare, delimiter = '=')
        gscript.message('mean = %s \n stddev = %s \n min = %s \n max = %s' % (stats['mean'],stats['stddev'], stats['min'], stats['max']))

        return soillossbare
    def Analyze(self):
        if self.hasSuperpixels:
            gscript.run_command('i.superpixels.slic', group=self.group, output=self.segment, compactness=2,
                                minsize=50, env=self.env)
        else:
            gscript.run_command('i.segment', group=self.group, output=self.segment, threshold=0.3, minsize=50, env=self.env)
            gscript.run_command('r.clump', input=self.segment, output=self.segment_clump, env=self.env)

        gscript.run_command('i.smap', group=self.group, subgroup=self.group, signaturefile=self.signature,
                            output=self.classification, goodness=self.reject, env=self.env)
        percentile = float(gscript.parse_command('r.univar', flags='ge', map=self.reject, env=self.env)['percentile_90'])
        gscript.mapcalc('{new} = if({classif} < {thres}, {classif}, null())'.format(new=self.filtered_classification,
                                                                                    classif=self.classification, thres=percentile), env=self.env)
        segments = self.segment if self.hasSuperpixels else self.segment_clump
        gscript.run_command('r.stats.quantile', base=segments, cover=self.filtered_classification, output=self.output, env=self.env)
예제 #51
0
def map_info(landscape):
    
    info = grass.parse_command('r.info', map=landscape, flags='g')
    
    # aqui deveriamos checar se a resolucao eh inteira... como fazer isso?
    dim = [int(info['rows']), int(info['cols'])]
    x_west = int(info['west'])
    x_east = int(info['east'])
    y_south = int(info['south'])
    y_north = int(info['north'])
    res_x = int(info['ewres'])
    res_y = int(info['nsres'])
    
    print 'dims = %d, %d; limits W-E: %d - %d, S-N: %d - %d; res = %d, %d' % (dim[0], dim[1], x_west, x_east, y_south, y_north, res_x, res_y)
    
    return dim, x_west, x_east, y_south, y_north, res_x, res_y
예제 #52
0
    def __init__(self,**optionsandflags):
        '''Process all arguments and prepare processing'''
        # add all options and flags as attributes (only nonempty ones)
        self.options = {}
        for o in optionsandflags:
            if optionsandflags[o]!='': self.options[o] = optionsandflags[o]
        self.__dict__.update(self.options)

        # get some location infos
        self.env=grass.gisenv()
        self.region=grass.region()
        self.proj=grass.parse_command('g.proj',flags='g')

        # convert res
        self.res = float(self.res)
        return
예제 #53
0
def map_info(landscape, usegrid = False, x_center = '', y_center = '', dims = ''):
    '''
    This function extracts information (extent, resolutin/grain, number of rows and columns) from the landscape,
    directly from the GRASS GIS DataBase
    Input:
    - landscape: name of the landscape (it may the HABMAT landscape - binary)
    
    Output:
    - dim: (nrows, ncols) - number of rows and columns of the landscape
    - x_west: western limit of the map
    - x_east: eastern limit of the map
    - y_south: southern limit of the map
    - y_north: northern limit of the map
    - res_x: resolution/grain (size of the pixel), in the west-east direction
    - res_y: resolution/grain (size of the pixel), in the south-north direction
    '''
    
    #landscape='lndscp_0002_Mapa0002_tif_HABMAT_HABMAT'
    #if usegrid:
        #set_region(x_col=x_center, y_row=y_center, dims=dims)
    #else:
        #grass.run_command('g.region', raster=landscape)
    info = grass.parse_command('r.info', map=landscape, flags='g')
        
    # aqui deveriamos checar se a resolucao eh inteira... como fazer isso?
    res_x = int(info['ewres'])
    res_y = int(info['nsres'])    
    if usegrid:
        dim = [dims[0]/res_y, dims[1]/res_x] # dims (y,x): in y/rows (meters), in x/cols (meters) 
        x_west = x_center-(dims[1]/2)
        x_east = x_center+(dims[1]/2)
        y_south = y_center-(dims[0]/2)
        y_north = y_center+(dims[0]/2)        
    else:
        dim = [int(info['rows']), int(info['cols'])]
        x_west = int(float(info['west']))
        x_east = int(float(info['east']))
        y_south = int(float(info['south']))
        y_north = int(float(info['north']))
    
    #print 'dims = %d, %d; limits W-E: %d - %d, S-N: %d - %d; res = %d, %d' % (dim[0], dim[1], x_west, x_east, y_south, y_north, res_x, res_y)
    
    return dim, x_west, x_east, y_south, y_north, res_x, res_y
    
#landscape_name = 'simulation_000001_p029_h059_HABMAT'
#dim, x_west, x_east, y_south, y_north, res_x, res_y = map_info(landscape=landscape_name)
#print 'dims = %d, %d; limits W-E: %d - %d, S-N: %d - %d; res = %d, %d' % (dim[0], dim[1], x_west, x_east, y_south, y_north, res_x, res_y)
def main():

    # process command options
    input = options['input']
    if not gs.find_file(input)['file']:
        gs.fatal(_("Raster map <%s> not found") % input)

    smooth = options['output']
    if gs.find_file(smooth)['file'] and not gs.overwrite():
        gs.fatal(_("Output map <%s> already exists") % smooth)

    sd = options['sd']
    try:
        sd = float(sd)
    except ValueError:
        if not gs.find_file(sd)['file']:
            gs.fatal(_("Raster map <%s> not found") % sd)

    alpha = float(options['alpha'])

    # 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)

    multiscalesmooth(input, smooth, sd, alpha)

    # restore original region
    gs.del_temp_region()

    return None
예제 #55
0
def main():
    infile = options['input']
    lesser = options['lesser']
    greater = options['greater']
    outfile = options['output']
    global METHOD
    METHOD = options['method']
    clumped = flags['c']
    diagonal = flags['d']
    islesser = False

    in_proj = grass.parse_command('g.proj', flags='g')

    # check non supported location
    if in_proj['unit'].lower() == 'degree':
        grass.fatal(_("Latitude-Longitude locations are not supported"))
    if in_proj['name'].lower() == 'xy_location_unprojected':
        grass.fatal(_("xy-locations are not supported"))
        grass.fatal(_("Need projected data with grids in metric units"))

    # check lesser and greater parameters
    if not lesser and not greater:
        grass.fatal(_("You have to specify one of lesser= or greater="))
    if lesser and greater:
        grass.fatal(_("lesser= and greater= are mutually exclusive"))
    if lesser:
        limit = float(lesser)
        islesser = True
    if greater and METHOD == 'rmarea':
        grass.fatal(_("You have to specify lesser= with method='rmarea'"))
    elif greater:
        limit = float(greater)

    if not grass.find_file(infile)['name']:
        grass.fatal(_("Raster map <%s> not found") % infile)

    if METHOD == 'reclass':
        reclass(infile, outfile, limit, clumped, diagonal, islesser)
    elif METHOD == 'rmarea':
        rmarea(infile, outfile, limit, in_proj['meters'])

    grass.message(_("Generating output raster map <%s>...") % outfile)
예제 #56
0
def getDbInfo():
	dbinfo = g.parse_command('db.connect',flags="p")
	dbstat = {}
	for i in range(len(dbinfo)):
		info = dict.keys(dbinfo)[i].split(":")[0]
		if info == "driver":
			e_key = dict.keys(dbinfo)[i].split(":")[0]
			e_val = dict.keys(dbinfo)[i].split(":")[1]
			driver=None
			if e_val == "pg":
				driver="postgres"
			dbstat[e_key] = driver
	for i in range(len(dbinfo)):
		if not dict.values(dbinfo)[i] == None:
			elems = dict.values(dbinfo)[i].split(",")
			for elem in elems:
				if len(elem.split('=')) > 1:
					e_key = elem.split('=')[0]
					e_val = elem.split('=')[1]
					dbstat[e_key] = e_val
	return(dbstat)
 def CalibrateModelBBox(self, event):
     if self.IsScanning():
         dlg = wx.MessageDialog(self, 'In order to calibrate, please stop scanning process first.',
                                'Stop scanning',
                                wx.OK | wx.ICON_WARNING)
         dlg.ShowModal()
         dlg.Destroy()
         return
     params = {}
     if self.calib_matrix:
         params['calib_matrix'] = self.calib_matrix
     params['rotate'] = self.scan['rotation_angle']
     zrange = ','.join(self.scan['trim_nsewtb'].split(',')[4:])
     params['zrange'] = zrange
     res = gscript.parse_command('r.in.kinect', flags='m', overwrite=True, **params)
     if not res['bbox']:
         gscript.message(_("Failed to find model extent"))
     offsetcm = 2
     n, s, e, w = [int(round(float(each))) for each in res['bbox'].split(',')]
     self.scanning_panel.trim['n'].SetValue(str(n + offsetcm))
     self.scanning_panel.trim['s'].SetValue(str(abs(s) + offsetcm))
     self.scanning_panel.trim['e'].SetValue(str(e + offsetcm))
     self.scanning_panel.trim['w'].SetValue(str(abs(w) + offsetcm))
예제 #58
0
파일: scatter.py 프로젝트: rkrug/grass-ci
    def OnRegression(self, event):
        """Displays regression information in messagebox
        """
        message = []
        title = _("Regression Statistics for Scatterplot(s)")

        for rpair in self.rasterList:
            if isinstance(rpair, tuple) == False:
                continue
            rast1, rast2 = rpair
            rast1 = rast1.split("@")[0]
            rast2 = rast2.split("@")[0]
            ret = grass.parse_command(
                "r.regression.line",
                mapx=rast1,
                mapy=rast2,
                flags="g",
                quiet=True,
                parse=(grass.parse_key_val, {"sep": "="}),
            )
            eqtitle = _("Regression equation for raster map <%(rast1)s> vs. <%(rast2)s>:\n\n") % {
                "rast1": rast1,
                "rast2": rast2,
            }
            eq = "   %s = %s + %s(%s)\n\n" % (rast2, ret["a"], ret["b"], rast1)
            num = "N = %s\n" % ret["N"]
            rval = "R = %s\n" % ret["R"]
            rsq = "R-squared = %f\n" % pow(float(ret["R"]), 2)
            ftest = "F = %s\n" % ret["F"]
            str = eqtitle + eq + num + rval + rsq + ftest
            message.append(str)

        stats = PlotStatsFrame(self, id=wx.ID_ANY, message=message, title=title)

        if stats.Show() == wx.ID_CLOSE:
            stats.Destroy()