Beispiel #1
0
def difference(real_elev, scanned_elev, new, zexag=1, env=None):
    """Compute difference and set color table using standard deviations"""
    tmp = 'tmp_resampled'
    gcore.run_command('r.resamp.interp',
                      input=real_elev,
                      output=tmp,
                      method='bilinear',
                      env=env)
    grast.mapcalc(f"{new} = {tmp} - {scanned_elev}", env=env)
    univar = gcore.parse_command("r.univar", flags="g", map=real_elev, env=env)
    std1 = zexag * float(univar["stddev"])
    std2 = zexag * 2 * std1
    std3 = zexag * 3 * std1
    rules = [
        f"-1000000 black",
        f"-{std3} black",
        f"-{std2} 202:000:032",
        f"-{std1} 244:165:130",
        "0 247:247:247",
        f"{std1} 146:197:222",
        f"{std2} 5:113:176",
        f"{std3} black",
        f"1000000 black",
    ]
    gcore.write_command("r.colors",
                        map=new,
                        rules="-",
                        stdin="\n".join(rules),
                        env=env)
def depression(scanned_elev, new, env, filter_depth=0, repeat=2):
    """Run r.fill.dir to compute depressions"""
    suffix = str(uuid.uuid4()).replace('-', '')[:5]
    input_dem = scanned_elev
    output = "tmp_filldir" + suffix
    tmp_dir = "tmp_dir" + suffix
    for i in range(repeat):
        gcore.run_command('r.fill.dir',
                          input=input_dem,
                          output=output,
                          direction=tmp_dir,
                          env=env)
        input_dem = output
    grast.mapcalc(
        '{new} = if({out} - {scan} > {depth}, {out} - {scan}, null())'.format(
            new=new, out=output, scan=scanned_elev, depth=filter_depth),
        env=env)
    gcore.write_command('r.colors',
                        map=new,
                        rules='-',
                        stdin='0% aqua\n100% blue',
                        env=env)
    gcore.run_command('g.remove',
                      flags='f',
                      type='raster',
                      name=[output, tmp_dir],
                      env=env)
def polylines(points_map, output, env):
    """Cluster points and connect points by line in each cluster"""
    tmp_cluster = 'tmp_cluster'
    gcore.run_command('v.cluster', flags='t', input=points_map, min=3,  layer='3', output=tmp_cluster, method='optics', env=env)
    cats = gcore.read_command('v.category', input=tmp_cluster, layer=3, option='print', env=env).strip()
    cats = list(set(cats.split()))
    line = ''
    for cat in cats:
        point_list = []
        distances = {}
        points = gcore.read_command('v.out.ascii', input=tmp_cluster, layer=3,
                                    type='point', cats=cat, format='point', env=env).strip().split()
        for point in points:
            point = point.split('|')[:2]
            point_list.append((float(point[0]), float(point[1])))
        for i, point1 in enumerate(point_list[:-1]):
            for point2 in point_list[i + 1:]:
                distances[(point1, point2)] = sqrt((point1[0] - point2[0]) * (point1[0] - point2[0]) +
                                                   (point1[1] - point2[1]) * (point1[1] - point2[1]))
        ordered = sorted(distances.items(), key=lambda x: x[1])[:len(points) - 1]
        for key, value in ordered:
            line += 'L 2 1\n'
            line += '{x} {y}\n'.format(x=key[0][0], y=key[0][1])
            line += '{x} {y}\n'.format(x=key[1][0], y=key[1][1])
            line += '1 {cat}\n\n'.format(cat=cat)
    gcore.write_command('v.in.ascii', input='-', stdin=line, output=output, format='standard', flags='n', env=env)
    gcore.run_command('v.to.rast', input=output, output=output, type='line', use='cat', env=env)
def importGeom(vname, typ, c, owrite, z, cat=None):
    psel = "SELECT lon, lat"
    if z == 'z':
        psel += ", altim"
        zcol = 3
    else:
        zcol = 0
    psel += " from %s" % typ
    if cat:
        psel += " where cat = '%s' order by _id" % cat
    points = returnAll(c, psel)
    wpoi = '\n'.join(['|'.join([str(col) for col in row]) for row in points])
    # import points using v.in.ascii
    try:
        grass.write_command('v.in.ascii',
                            flags='t%s' % z,
                            input='-',
                            z=zcol,
                            output=vname,
                            stdin=wpoi,
                            overwrite=owrite,
                            quiet=True)
    except CalledModuleError:
        grass.fatal(_("Error importing %s" % vname))
    return points
def difference(real_elev, scanned_elev, new, color_coeff=1, env=None):
    """!Computes difference of original and scanned (scan - orig).
    color_coeff modifies the intensity of the color, values > 1 mean the difference
    shows only bigger changes, values < 1 highlight smaller changes (and noise)"""
    tmp = 'tmp_resampled'
    gcore.run_command('r.resamp.interp',
                      input=real_elev,
                      output=tmp,
                      method='bilinear',
                      env=env)
    gcore.run_command('r.mapcalc',
                      expression='{diff} = {scan} - {real}'.format(
                          diff=new, real=tmp, scan=scanned_elev),
                      env=env)
    info = grast.raster_info(real_elev)
    range = info['max'] - info['min']
    percentages = [-1000, -100, -50, -5, 5, 50, 100, 1000]
    colors = [
        'black', 'black', 'blue', 'white', 'white', 'red', 'black', 'black'
    ]
    rules = []
    for p, c in zip(percentages, colors):
        p = range / 100. * p * color_coeff
        rules.append('{p} {c}'.format(p=p, c=c))
    gcore.write_command('r.colors',
                        map=new,
                        rules='-',
                        stdin='\n'.join(rules),
                        env=env)
def main():
    options, flags = gcore.parser()
    probability = options['probability']
    output = options['output']
    count = int(options['count'])

    gcore.use_temp_region()

    # probability map
    probab_01 = 'probability_01_' + str(os.getpid())
    TMP_RAST.append(probab_01)
    info = grast.raster_info(probability)
    gcore.write_command('r.recode', flags='d', input=probability, output=probab_01,
                        title="Recoded probability map to 0 to 1",
                        rules='-', stdin='{minim}:{maxim}:0:1'.format(minim=info['min'], maxim=info['max']))
    mean = gcore.parse_key_val(gcore.read_command('r.univar', map=probab_01, flags='g'),
                               val_type=float)['mean']
    resolution = count / (mean * (info['north'] - info['south'] + info['east'] - info['west']))
    resolution = sqrt((mean * (info['north'] - info['south']) * (info['east'] - info['west'])) / count)
    gcore.run_command('g.region', res=resolution)

    random_name = 'random_' + str(os.getpid())
    point_map = 'points_' + str(os.getpid())
    point_grid = 'points_' + str(os.getpid())
    TMP_RAST.append(random_name)
    TMP_RAST.append(point_map)
    TMP_VECT.append(point_grid)

    gcore.run_command('r.surf.random', output=random_name, min=0, max=1)
    grast.mapcalc(exp='{point_map} = if({rand} <= {prob}, 1, null())'.format(rand=random_name,
                                                                             prob=probab_01,
                                                                             point_map=point_map))
    gcore.run_command('r.to.vect', flags='t', input=point_map, output=point_grid, type='point')
    gcore.run_command('v.perturb', input=point_grid, output=output,
                      parameter=resolution / 2., seed=os.getpid())
def viewshed(scanned_elev,
             output,
             vector,
             visible_color,
             invisible_color,
             obs_elev=1.7,
             env=None):
    coordinates = gcore.read_command('v.out.ascii',
                                     input=vector,
                                     separator=',',
                                     env=env).strip()
    coordinate = None
    for line in coordinates.split(os.linesep):
        try:
            coordinate = [float(c) for c in line.split(',')[0:2]]
        except ValueError:  # no points in map
            pass
        break
    if coordinate:
        gcore.run_command('r.viewshed',
                          flags='b',
                          input=scanned_elev,
                          output=output,
                          coordinates=coordinate,
                          observer_elevation=obs_elev,
                          env=env)
        gcore.run_command('r.null', map=output, null=0, env=env)
        gcore.write_command('r.colors',
                            map=output,
                            rules='-',
                            stdin='0 {invis}\n1 {vis}'.format(
                                vis=visible_color, invis=invisible_color),
                            env=env)
def polylines(points_map, output, env):
    """Cluster points and connect points by line in each cluster"""
    tmp_cluster = 'tmp_cluster'
    gcore.run_command('v.cluster',
                      flags='t',
                      input=points_map,
                      min=3,
                      layer='3',
                      output=tmp_cluster,
                      method='optics',
                      env=env)
    cats = gcore.read_command('v.category',
                              input=tmp_cluster,
                              layer=3,
                              option='print',
                              env=env).strip()
    cats = list(set(cats.split()))
    line = ''
    for cat in cats:
        point_list = []
        distances = {}
        points = gcore.read_command('v.out.ascii',
                                    input=tmp_cluster,
                                    layer=3,
                                    type='point',
                                    cats=cat,
                                    format='point',
                                    env=env).strip().split()
        for point in points:
            point = point.split('|')[:2]
            point_list.append((float(point[0]), float(point[1])))
        for i, point1 in enumerate(point_list[:-1]):
            for point2 in point_list[i + 1:]:
                distances[(point1, point2)] = sqrt((point1[0] - point2[0]) *
                                                   (point1[0] - point2[0]) +
                                                   (point1[1] - point2[1]) *
                                                   (point1[1] - point2[1]))
        ordered = sorted(distances.items(),
                         key=lambda x: x[1])[:len(points) - 1]
        for key, value in ordered:
            line += 'L 2 1\n'
            line += '{x} {y}\n'.format(x=key[0][0], y=key[0][1])
            line += '{x} {y}\n'.format(x=key[1][0], y=key[1][1])
            line += '1 {cat}\n\n'.format(cat=cat)
    gcore.write_command('v.in.ascii',
                        input='-',
                        stdin=line,
                        output=output,
                        format='standard',
                        flags='n',
                        env=env)
    gcore.run_command('v.to.rast',
                      input=output,
                      output=output,
                      type='line',
                      use='cat',
                      env=env)
def polygons(points_map, output, env):
    """Clusters markers together and creates polygons.
    Requires GRASS 7.1."""
    tmp_cluster = 'tmp_cluster'
    tmp_hull = 'tmp_hull'
    gcore.run_command('v.cluster',
                      flags='t',
                      input=points_map,
                      min=3,
                      layer='3',
                      output=tmp_cluster,
                      method='optics',
                      env=env)
    cats = gcore.read_command('v.category',
                              input=tmp_cluster,
                              layer='3',
                              option='print',
                              env=env).strip().split()
    cats_list = list(set(cats))
    cats_dict = dict([(x, cats.count(x)) for x in cats_list])
    for cat in cats_list:
        if cats_dict[cat] > 2:
            gcore.run_command('v.hull',
                              input=tmp_cluster,
                              output=tmp_hull + "_%s" % cat,
                              cats=cat,
                              layer='3',
                              env=env)
        elif cats_dict[cat] == 2:
            points = gcore.read_command('v.out.ascii',
                                        input=tmp_cluster,
                                        format='point',
                                        separator='space',
                                        layer='3',
                                        cats=cat,
                                        env=env).strip().splitlines()
            ascii = 'L 2 1\n' + points[0] + '\n' + points[1] + '\n' + '1 1'
            gcore.write_command('v.in.ascii',
                                format='standard',
                                input='-',
                                flags='n',
                                output=tmp_hull + '_%s' % cat,
                                stdin=ascii,
                                env=env)
    gcore.run_command('v.patch',
                      input=[tmp_hull + '_%s' % cat for cat in cats_list],
                      output=output,
                      env=env)
    gcore.run_command('v.to.rast',
                      input=output,
                      output=output,
                      type='area,line',
                      use='val',
                      value=1,
                      env=env)
def depression(scanned_elev, new, env, filter_depth=0, repeat=2):
    """Run r.fill.dir to compute depressions"""
    suffix = str(uuid.uuid4()).replace('-', '')[:5]
    input_dem = scanned_elev
    output = "tmp_filldir" + suffix
    tmp_dir = "tmp_dir" + suffix
    for i in range(repeat):
        gcore.run_command('r.fill.dir', input=input_dem, output=output, direction=tmp_dir, env=env)
        input_dem = output
    grast.mapcalc('{new} = if({out} - {scan} > {depth}, {out} - {scan}, null())'.format(new=new, out=output, scan=scanned_elev, depth=filter_depth), env=env)
    gcore.write_command('r.colors', map=new, rules='-', stdin='0% aqua\n100% blue', env=env)
    gcore.run_command('g.remove', flags='f', type='raster', name=[output, tmp_dir], env=env)
Beispiel #11
0
def main():
    test_file = options['test']

    expected = grass.tempfile()
    result = grass.tempfile()

    dbconn = grassdb.db_connection()
    grass.message(_("Using DB driver: %s") % dbconn['driver'])

    infile = os.path.join(os.environ['GISBASE'], 'etc', 'db.test', test_file)
    inf = file(infile)

    while True:
        type = inf.readline()
        if not type:
            break
        type = type.rstrip('\r\n')

        sql = inf.readline().rstrip('\r\n')
        sys.stdout.write(sql + '\n')

        # Copy expected result to temp file

        try:
            if type == 'X':
                grass.write_command('db.execute', input='-', stdin=sql + '\n')
            else:
                resf = file(result, 'w')
                grass.write_command('db.select',
                                    input='-',
                                    flags='c',
                                    stdin=sql + '\n',
                                    stdout=resf)
                resf.close()

        except CalledModuleError:
            grass.error("EXECUTE: ******** ERROR ********")
        else:
            grass.message(_("EXECUTE: OK"))

        expf = file(expected, 'w')
        while True:
            res = inf.readline().rstrip('\r\n')
            if not res:
                break
            expf.write(res + '\n')
        expf.close()

        if type == 'S':
            if grass.call(['diff', result, expected]) != 0:
                grass.error("RESULT: ******** ERROR ********")
            else:
                grass.message(_("RESULT: OK"))
Beispiel #12
0
def main():
    test_file = options["test"]

    expected = gcore.tempfile()
    result = gcore.tempfile()

    dbconn = grassdb.db_connection()
    gcore.message(_("Using DB driver: %s") % dbconn["driver"])

    infile = os.path.join(os.environ["GISBASE"], "etc", "db.test", test_file)
    inf = open(infile)

    while True:
        type = inf.readline()
        if not type:
            break
        type = type.rstrip("\r\n")

        sql = inf.readline().rstrip("\r\n")
        sys.stdout.write(sql + "\n")

        # Copy expected result to temp file
        try:
            if type == "X":
                gcore.write_command("db.execute", input="-", stdin=sql + "\n")
            else:
                resf = open(result, "w")
                gcore.write_command("db.select",
                                    input="-",
                                    flags="c",
                                    stdin=sql + "\n",
                                    stdout=resf)
                resf.close()

        except CalledModuleError:
            gcore.error("EXECUTE: ******** ERROR ********")
        else:
            gcore.message(_("EXECUTE: OK"))

        expf = open(expected, "w")
        while True:
            res = inf.readline().rstrip("\r\n")
            if not res:
                break
            expf.write(res + "\n")
        expf.close()

        if type == "S":
            if gcore.call(["diff", result, expected]) != 0:
                gcore.error("RESULT: ******** ERROR ********")
            else:
                gcore.message(_("RESULT: OK"))
Beispiel #13
0
 def test_write_labels_unicode(self):
     """This tests if Python module works"""
     find_program("ls", "--version")
     write_command(
         "r.category",
         map=self.raster,
         rules="-",
         stdin="1:kůň\n2:kráva\n3:ovečka\n4:býk",
         separator=":",
     )
     res = read_command("r.category", map=self.raster, separator=":").strip()
     self.assertEquals(res, "1:kůň\n2:kráva\n3:ovečka\n4:býk")
     self.assertIsInstance(res, str)
def viewshed(scanned_elev, output, vector, visible_color, invisible_color, obs_elev=1.7, env=None):
    coordinates = gcore.read_command('v.out.ascii', input=vector, separator=',', env=env).strip()
    coordinate = None
    for line in coordinates.split(os.linesep):
        try:
            coordinate = [float(c) for c in line.split(',')[0:2]]
        except ValueError:  # no points in map
            pass
        break
    if coordinate:
        gcore.run_command('r.viewshed', flags='b', input=scanned_elev, output=output, coordinates=coordinate, observer_elevation=obs_elev, env=env)
        gcore.run_command('r.null', map=output, null=0, env=env)
        gcore.write_command('r.colors', map=output,  rules='-', stdin='0 {invis}\n1 {vis}'.format(vis=visible_color, invis=invisible_color), env=env)
Beispiel #15
0
def main():
    test_file = options['test']

    expected = grass.tempfile()
    result = grass.tempfile()

    dbconn = grassdb.db_connection()
    grass.message(_("Using DB driver: %s") % dbconn['driver'])

    infile = os.path.join(os.environ['GISBASE'], 'etc', 'db.test', test_file)
    inf = file(infile)

    while True:
	type = inf.readline()
	if not type:
	    break
	type = type.rstrip('\r\n')

	sql = inf.readline().rstrip('\r\n')
	sys.stdout.write(sql + '\n')

	# Copy expected result to temp file

        try:
            if type == 'X':
                grass.write_command('db.execute', input = '-', stdin = sql + '\n')
            else:
                resf = file(result, 'w')
                grass.write_command('db.select', input = '-', flags = 'c', stdin = sql + '\n', stdout = resf)
                resf.close()

        except CalledModuleError:
            grass.error("EXECUTE: ******** ERROR ********")
        else:
            grass.message(_("EXECUTE: OK"))

	expf = file(expected, 'w')
	while True:
	    res = inf.readline().rstrip('\r\n')
	    if not res:
		break
	    expf.write(res + '\n')
	expf.close()

	if type == 'S':
	    if grass.call(['diff', result, expected]) != 0:
		grass.error("RESULT: ******** ERROR ********")
	    else:
		grass.message(_("RESULT: OK"))
 def test_write_labels_bytes(self):
     """This tests if Python module works"""
     write_command(
         "r.category",
         map=self.raster,
         rules="-",
         stdin="1:kůň\n2:kráva\n3:ovečka\n4:býk",
         separator=":",
         encoding=None,
     )
     res = read_command(
         "r.category", map=self.raster, separator=":", encoding=None
     ).strip()
     self.assertEquals(res, encode("1:kůň\n2:kráva\n3:ovečka\n4:býk"))
     self.assertIsInstance(res, bytes)
def change_detection(before, after, change, height_threshold, cells_threshold, add, max_detected, debug, env):
    diff_thr = 'diff_thr_' + str(uuid.uuid4()).replace('-', '')
    diff_thr_clump = 'diff_thr_clump_' + str(uuid.uuid4()).replace('-', '')
    coeff = gcore.parse_command('r.regression.line', mapx=after, mapy=before, flags='g', env=env)
    grast.mapcalc('diff = {a} + {b} * {after} - {before}'.format(a=coeff['a'], b=coeff['b'],before=before,after=after), env=env)
    try:
        if add:
            grast.mapcalc("{diff_thr} = if(({a} + {b} * {after} - {before}) > {thr1} &&"
                          " ({a} + {b} * {after} - {before}) < {thr2}, 1, null())".format(a=coeff['a'], b=coeff['b'],
                                                                                          diff_thr=diff_thr, after=after,
                                                                                          before=before, thr1=height_threshold[0],
                                                                                          thr2=height_threshold[1]), env=env)
        else:
            grast.mapcalc("{diff_thr} = if(({before} - {a} + {b} * {after}) > {thr}, 1, null())".format(diff_thr=diff_thr,
                                                                                                        a=coeff['a'], b=coeff['b'],
                                                                                                        after=after, before=before,
                                                                                                        thr=height_threshold), env=env)

        gcore.run_command('r.clump', input=diff_thr, output=diff_thr_clump, env=env)
        stats = gcore.read_command('r.stats', flags='cn', input=diff_thr_clump, sort='desc', env=env).strip().splitlines()
        if debug:
            print 'DEBUG: {}'.format(stats)
        if len(stats) > 0 and stats[0]:
            cats = []
            found = 0
            for stat in stats:
                if found >= max_detected:
                    break
                if float(stat.split()[1]) < cells_threshold[1] and float(stat.split()[1]) > cells_threshold[0]: # larger than specified number of cells
                    found += 1
                    cat, value = stat.split()
                    cats.append(cat)
            if cats:
                rules = ['{c}:{c}:1'.format(c=c) for c in cats]
                gcore.write_command('r.recode', input=diff_thr_clump, output=change, rules='-', stdin='\n'.join(rules), env=env)
                gcore.run_command('r.volume', flags='f', input=change, clump=diff_thr_clump, centroids=change, env=env)
            else:
                gcore.warning("No change found!")
                gcore.run_command('v.edit', map=change, tool='create', env=env)
        else:
            gcore.warning("No change found!")
            gcore.run_command('v.edit', map=change, tool='create', env=env)

        gcore.run_command('g.remove', flags='f', type=['raster'], name=[diff_thr, diff_thr_clump], env=env)
    except:
        gcore.run_command('g.remove', flags='f', type=['raster'], name=[diff_thr, diff_thr_clump], env=env)
def usped(scanned_elev, k_factor, c_factor, flowacc, slope, aspect, new, env):
    """!Computes net erosion and deposition (USPED model)"""
    sedflow = 'sedflow_' + str(os.getpid())
    qsx = 'qsx_' + str(os.getpid())
    qsxdx = 'qsxdx_' + str(os.getpid())
    qsy = 'qsy_' + str(os.getpid())
    qsydy = 'qsydy_' + str(os.getpid())
    slope_sm = 'slope_sm' + str(os.getpid())
    gcore.run_command('r.neighbors', overwrite=True, input=slope, output=slope_sm, size=5, env=env)
    gcore.run_command('r.mapcalc', expression="{sedflow} = 270. * {k_factor} * {c_factor} * {flowacc} * sin({slope})".format(c_factor=c_factor, k_factor=k_factor, slope=slope_sm, flowacc=flowacc, sedflow=sedflow), overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{qsx} = {sedflow} * cos({aspect})".format(sedflow=sedflow, aspect=aspect, qsx=qsx), overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{qsy} = {sedflow} * sin({aspect})".format(sedflow=sedflow, aspect=aspect, qsy=qsy), overwrite=True, env=env)
    gcore.run_command('r.slope.aspect', elevation=qsx, dx=qsxdx, overwrite=True, env=env)
    gcore.run_command('r.slope.aspect', elevation=qsy, dy=qsydy, overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{erdep} = {qsxdx} + {qsydy}".format(erdep=new, qsxdx=qsxdx, qsydy=qsydy), overwrite=True, env=env)
    gcore.write_command('r.colors', map=new,  rules='-', stdin='-15000 100 0 100\n-100 magenta\n-10 red\n-1 orange\n-0.1 yellow\n0 200 255 200\n0.1 cyan\n1 aqua\n10 blue\n100 0 0 100\n18000 black', env=env)

    gcore.run_command('g.remove', rast=[sedflow, qsx, qsxdx, qsy, qsydy, slope_sm])
def difference(real_elev, scanned_elev, new, color_coeff=1, env=None):
    """!Computes difference of original and scanned (scan - orig).
    color_coeff modifies the intensity of the color, values > 1 mean the difference
    shows only bigger changes, values < 1 highlight smaller changes (and noise)"""
    tmp = 'tmp_resampled'
    gcore.run_command('r.resamp.interp', input=real_elev, output=tmp,
                      method='bilinear', env=env)
    gcore.run_command('r.mapcalc',
                      expression='{diff} = {scan} - {real}'.format(diff=new, real=tmp,
                                                                   scan=scanned_elev), env=env)
    info = grast.raster_info(real_elev)
    range = info['max'] - info['min']
    percentages = [-1000, -100, -50, -5, 5, 50, 100, 1000]
    colors = ['black', 'black', 'blue', 'white', 'white', 'red', 'black', 'black']
    rules = []
    for p, c in zip(percentages, colors):
        p = range / 100. * p * color_coeff
        rules.append('{p} {c}'.format(p=p, c=c))
    gcore.write_command('r.colors', map=new, rules='-', stdin='\n'.join(rules), env=env)
def usped(scanned_elev, k_factor, c_factor, flowacc, slope, aspect, new, env):
    """!Computes net erosion and deposition (USPED model)"""
    suffix = str(uuid.uuid4()).replace('-', '')[:5]
    sedflow = 'sedflow_' + suffix
    qsx = 'qsx_' + suffix
    qsxdx = 'qsxdx_' + suffix
    qsy = 'qsy_' + suffix
    qsydy = 'qsydy_' + suffix
    slope_sm = 'slope_sm' + suffix
    gcore.run_command('r.neighbors', overwrite=True, input=slope, output=slope_sm, size=5, env=env)
    gcore.run_command('r.mapcalc', expression="{sedflow} = 270. * {k_factor} * {c_factor} * {flowacc} * sin({slope})".format(c_factor=c_factor, k_factor=k_factor, slope=slope_sm, flowacc=flowacc, sedflow=sedflow), overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{qsx} = {sedflow} * cos({aspect})".format(sedflow=sedflow, aspect=aspect, qsx=qsx), overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{qsy} = {sedflow} * sin({aspect})".format(sedflow=sedflow, aspect=aspect, qsy=qsy), overwrite=True, env=env)
    gcore.run_command('r.slope.aspect', elevation=qsx, dx=qsxdx, overwrite=True, env=env)
    gcore.run_command('r.slope.aspect', elevation=qsy, dy=qsydy, overwrite=True, env=env)
    gcore.run_command('r.mapcalc', expression="{erdep} = {qsxdx} + {qsydy}".format(erdep=new, qsxdx=qsxdx, qsydy=qsydy), overwrite=True, env=env)
    gcore.write_command('r.colors', map=new,  rules='-', stdin='-15000 100 0 100\n-100 magenta\n-10 red\n-1 orange\n-0.1 yellow\n0 200 255 200\n0.1 cyan\n1 aqua\n10 blue\n100 0 0 100\n18000 black', env=env)

    gcore.run_command('g.remove', flags='f', type='raster', name=[sedflow, qsx, qsxdx, qsy, qsydy, slope_sm])
def polygons(points_map, output, env):
    """Clusters markers together and creates polygons.
    Requires GRASS 7.1."""
    tmp_cluster = 'tmp_cluster'
    tmp_hull = 'tmp_hull'
    gcore.run_command('v.cluster', flags='t', input=points_map, min=3,  layer='3', output=tmp_cluster, method='optics', env=env)
    cats = gcore.read_command('v.category', input=tmp_cluster, layer='3', option='print', env=env).strip().split()
    cats_list = list(set(cats))
    cats_dict = dict([(x, cats.count(x)) for x in cats_list])
    for cat in cats_list:
        if cats_dict[cat] > 2:
            gcore.run_command('v.hull', input=tmp_cluster, output=tmp_hull + "_%s" % cat, cats=cat, layer='3', env=env)
        elif cats_dict[cat] == 2:
            points = gcore.read_command('v.out.ascii', input=tmp_cluster, format='point',
                                        separator='space', layer='3', cats=cat, env=env).strip().splitlines()
            ascii = 'L 2 1\n' + points[0] + '\n' + points[1] + '\n' + '1 1'
            gcore.write_command('v.in.ascii', format='standard', input='-',
                                flags='n', output=tmp_hull + '_%s' % cat, stdin=ascii, env=env)
    gcore.run_command('v.patch', input=[tmp_hull + '_%s' % cat for cat in cats_list], output=output, env=env)
    gcore.run_command('v.to.rast', input=output, output=output, type='area,line', use='val', value=1, env=env)
Beispiel #22
0
def main():
    indb = options['database']
    prefix = options['basename']
    env = grass.gisenv()
    #fix sqlite3 db field string multibyte character problem
    sys.setdefaultencoding('utf-8')
    # check if 3d or not
    if flags['z']:
        d3 = 'z'
    else:
        d3 = ''
    owrite = grass.overwrite()
    # check if location it is latlong
    if grass.locn_is_latlong():
        locn = True
    else:
        locn = False
    # connection to sqlite geopaparazzi database
    import sqlite3
    conn = sqlite3.connect(indb)
    curs = conn.cursor()
    # if it is not a latlong location create a latlong location on the fly
    if not locn:
        # create new location and move to it creating new gisrc file
        new_loc = basename(grass.tempfile(create=False))
        new_loc_name = 'geopaparazzi_%s' % new_loc
        grass.create_location(dbase=env['GISDBASE'], epsg='4326',
                              location=new_loc_name,
                              desc='Temporary location for v.in.geopaparazzi')
        grc = os.getenv('GISRC')
        shutil.copyfile(grc, grc + '.old')
        newrc = open(grc, 'w')
        newrc.write('GISDBASE: %s\n' % env['GISDBASE'])
        newrc.write('LOCATION_NAME: %s\n' % new_loc_name)
        newrc.write('MAPSET: PERMANENT\n')
        newrc.write('GRASS_GUI: text\n')
        newrc.close()
        grass.run_command('db.connect', flags="d", quiet=True)

    # load bookmarks
    if flags['b']:
        # check if elements in bookmarks table are more the 0
        if checkEle(curs, 'bookmarks') != 0:
            bookname = prefix + '_book'
            pois = importGeom(bookname, 'bookmarks', curs, owrite, '')
            sql = 'CREATE TABLE %s (cat int, text text)' % bookname
            grass.write_command('db.execute', input='-', stdin=sql)
            # select attributes
            sql = "select text from bookmarks order by _id"
            allattri = returnClear(curs, sql)
            # add values using insert statement
            idcat = 1
            for row in allattri:
                values = "%d,'%s'" % (idcat, str(row))
                sql = "insert into %s values(%s)" % (bookname, values)
                grass.write_command('db.execute', input='-', stdin=sql)
                idcat += 1
            # at the end connect table to vector
            grass.run_command('v.db.connect', map=bookname,
                              table=bookname, quiet=True)
        else:
            grass.warning(_("No bookmarks found, escape them"))
    # load images
    if flags['i']:
        # check if elements in images table are more the 0
        if checkEle(curs, 'images') != 0:
            imagename = prefix + '_image'
            pois = importGeom(imagename, 'images', curs, owrite, d3)
            sql = 'CREATE TABLE %s (cat int, azim int, ' % imagename
            sql += 'path text, ts text, text text)'
            grass.write_command('db.execute', input='-', stdin=sql)
            # select attributes
            sql = "select azim, path, ts, text from images order by _id"
            allattri = returnAll(curs, sql)
            # add values using insert statement
            idcat = 1
            for row in allattri:
                values = "%d,'%d','%s','%s','%s'" % (idcat, row[0],
                                                     str(row[1]), str(row[2]),
                                                     str(row[3]))
                sql = "insert into %s values(%s)" % (imagename, values)
                grass.write_command('db.execute', input='-', stdin=sql)
                idcat += 1
            # at the end connect table to vector
            grass.run_command('v.db.connect', map=imagename, table=imagename,
                              quiet=True)
        else:
            grass.warning(_("No images found, escape them"))
    # if tracks or nodes should be imported create a connection with sqlite3
    # load notes
    if flags['n']:
        # check if elements in notes table are more the 0
        if checkEle(curs, 'notes') != 0:
            # select each categories
            categories = returnClear(curs, "select cat from notes group by cat")
            # for each category
            for cat in categories:
                # select lat, lon for create point layer
                catname = prefix + '_notes_' + cat
                pois = importGeom(catname, 'notes', curs, owrite, d3, cat)
                # select form to understand the number
                forms = returnClear(curs, "select _id from notes where cat = '%s' "
                                    "and form is not null order by _id" % cat)
                # if number of form is different from 0 and number of point
                # remove the vector because some form it is different
                if len(forms) != 0 and len(forms) != len(pois):
                    grass.run_command('g.remove', flags='f', type='vector', name=catname, quiet=True)
                    grass.warning(_("Vector %s not imported because number"
                                    " of points and form is different"))
                # if form it's 0 there is no form
                elif len(forms) == 0:
                    # create table without form
                    sql = 'CREATE TABLE %s (cat int, ts text, ' % catname
                    sql += 'text text, geopap_cat text)'
                    grass.write_command('db.execute', input='-', stdin=sql)
                    # select attributes
                    sql = "select ts, text, cat from notes where "\
                        "cat='%s' order by _id" % cat
                    allattri = returnAll(curs, sql)
                    # add values using insert statement
                    idcat = 1
                    for row in allattri:
                        values = "%d,'%s','%s','%s'" % (idcat, str(row[0]),
                                                        str(row[1]),
                                                        str(row[2]))
                        sql = "insert into %s values(%s)" % (catname, values)
                        grass.write_command('db.execute', input='-', stdin=sql)
                        idcat += 1
                    # at the end connect table to vector
                    grass.run_command('v.db.connect', map=catname,
                                      table=catname, quiet=True)
                # create table with form
                else:
                    # select all the attribute
                    sql = "select ts, text, cat, form from notes where "\
                          "cat='%s' order by _id" % cat
                    allattri = returnAll(curs, sql)
                    # return string of form's categories too create table
                    keys = returnFormKeys(allattri)
                    sql = 'CREATE TABLE %s (cat int, ts text, ' % catname
                    sql += 'text text, geopap_cat text %s)' % keys
                    grass.write_command('db.execute', input='-', stdin=sql)
                    # it's for the number of categories
                    idcat = 1
                    # for each feature insert value
                    for row in allattri:
                        values = "%d,'%s','%s','%s'," % (idcat, str(row[0]),
                                                         str(row[1]),
                                                         str(row[2]))
                        values += returnFormValues(row[3])
                        sql = "insert into %s values(%s)" % (catname, values)
                        grass.write_command('db.execute', input='-', stdin=sql)
                        idcat += 1
                    # at the end connect table with vector
                    grass.run_command('v.db.connect', map=catname,
                                      table=catname, quiet=True)
        else:
            grass.warning(_("No notes found, escape them"))
    # load tracks
    if flags['t']:
        # check if elements in bookmarks table are more the 0
        if checkEle(curs, 'gpslogs') != 0:
            tracksname = prefix + '_tracks'
            # define string for insert data at the end
            tracks = ''
            # return ids of tracks
            ids = returnClear(curs, "select _id from gpslogs")
            # for each track
            for i in ids:
                # select all the points coordinates
                tsel = "select lon, lat"
                if flags['z']:
                    tsel += ", altim"
                tsel += " from gpslog_data where logid=%s order by _id" % i
                trackpoints = returnAll(curs, tsel)
                wpoi = '\n'.join(['|'.join([str(col) for col in row]) for row in trackpoints])
                tracks += "%s\n" % wpoi
                if flags['z']:
                    tracks += 'NaN|NaN|Nan\n'
                else:
                    tracks += 'NaN|Nan\n'
            # import lines
            try:
                grass.write_command('v.in.lines', flags=d3, input='-',
                                    out=tracksname, stdin=tracks,
                                    overwrite=owrite, quiet=True)
            except CalledModuleError:
                grass.fatal(_("Error importing %s" % tracksname))
            # create table for line
            sql = 'CREATE TABLE %s (cat int, startts text, ' % tracksname
            sql += 'endts text, text text, color text, width int)'
            grass.write_command('db.execute', input='-', stdin=sql)
            sql = "select logid, startts, endts, text, color, width from" \
                  " gpslogs, gpslogsproperties where gpslogs._id=" \
                  "gpslogsproperties.logid"
            # return attributes
            allattri = returnAll(curs, sql)
            # for each line insert attribute
            for row in allattri:
                values = "%d,'%s','%s','%s','%s',%d" % (row[0], str(row[1]),
                                                        str(row[2]),
                                                        str(row[3]),
                                                        str(row[4]), row[5])
                sql = "insert into %s values(%s)" % (tracksname, values)
                grass.write_command('db.execute', input='-', stdin=sql)
            # at the end connect map with table
            grass.run_command('v.db.connect', map=tracksname,
                              table=tracksname, quiet=True)
        else:
            grass.warning(_("No tracks found, escape them"))
    # if location it's not latlong reproject it
    if not locn:
        # copy restore the original location
        shutil.copyfile(grc + '.old', grc)
        # reproject bookmarks
        if flags['b'] and checkEle(curs, 'bookmarks') != 0:
            grass.run_command('v.proj', quiet=True, input=bookname,
                              location='geopaparazzi_%s' % new_loc,
                              mapset='PERMANENT')
        # reproject images
        if flags['i'] and checkEle(curs, 'images') != 0:
            grass.run_command('v.proj', quiet=True, input=imagename,
                              location='geopaparazzi_%s' % new_loc,
                              mapset='PERMANENT')
        # reproject notes
        if flags['n'] and checkEle(curs, 'notes') != 0:
            for cat in categories:
                catname = prefix + '_node_' + cat
                grass.run_command('v.proj', quiet=True, input=catname,
                                  location='geopaparazzi_%s' % new_loc,
                                  mapset='PERMANENT')
        # reproject track
        if flags['t'] and checkEle(curs, 'gpslogs') != 0:
            grass.run_command('v.proj', quiet=True, input=tracksname,
                              location='geopaparazzi_%s' % new_loc,
                              mapset='PERMANENT')
Beispiel #23
0
def main():
    layers = options["map"].split(",")

    if len(layers) < 2:
        gcore.error(_("At least 2 maps are required"))

    tmpfile = gcore.tempfile()

    for map in layers:
        if not gcore.find_file(map, element="cell")["file"]:
            gcore.fatal(_("Raster map <%s> not found") % map)

    gcore.write_command("d.text", color="black", size=4, line=1, stdin="CORRELATION")

    os.environ["GRASS_RENDER_FILE_READ"] = "TRUE"

    colors = "red black blue green gray violet".split()
    line = 2
    iloop = 0
    jloop = 0
    for iloop, i in enumerate(layers):
        for jloop, j in enumerate(layers):
            if i != j and iloop <= jloop:
                color = colors[0]
                colors = colors[1:]
                colors.append(color)
                gcore.write_command("d.text", color=color, size=4, line=line, stdin="%s %s" % (i, j))
                line += 1

                ofile = file(tmpfile, "w")
                gcore.run_command("r.stats", flags="cnA", input=(i, j), stdout=ofile)
                ofile.close()

                ifile = file(tmpfile, "r")
                first = True
                for l in ifile:
                    f = l.rstrip("\r\n").split(" ")
                    x = float(f[0])
                    y = float(f[1])
                    if first:
                        minx = maxx = x
                        miny = maxy = y
                        first = False
                    if minx > x:
                        minx = x
                    if maxx < x:
                        maxx = x
                    if miny > y:
                        miny = y
                    if maxy < y:
                        maxy = y
                ifile.close()

                kx = 100.0 / (maxx - minx + 1)
                ky = 100.0 / (maxy - miny + 1)

                p = gcore.feed_command("d.graph", color=color)
                ofile = p.stdin

                ifile = file(tmpfile, "r")
                for l in ifile:
                    f = l.rstrip("\r\n").split(" ")
                    x = float(f[0])
                    y = float(f[1])
                    ofile.write("icon + 0.1 %f %f\n" % ((x - minx + 1) * kx, (y - miny + 1) * ky))
                ifile.close()

                ofile.close()
                p.wait()

    try_remove(tmpfile)
Beispiel #24
0
def nanrunoff(conf,inputs,outputs):

	# Set path result rain idw method
	path = '/var/www/html/dl/data/nanrainfall/'
	#path = '/usr/local/lib/geoserver-2.5/data_dir/coverages/result_data/'
	#path = '/var/lib/tomcat6/webapps/geoserver/data/coverages/result_data/'
	#path2 = '/home/user/data/chai/rasters/'
	t = time.strftime("%Y%m%d:%H%M%S")
	print t+"=> Hello times it work[200]!"
	connection = psycopg2.connect(dbname='nanrunf', host='localhost', port='5432', user='******', password='******')
	
	# Import point rainfall data from PostgreSQL/PostGIS
	mg.run_command('v.in.ogr', dsn='PG:dbname=nanrunf', layer='nan_raingrass', output='nan_raingrass', overwrite= True)
	
	# Set Extent and Interpolation IDW Method
	#mg.run_command('g.region', rast='rainthai_idw@PERMANENT',res='1000', quiet= True)
	mg.run_command('g.region', n='2172120.86468637', e='748094.237955', s='1735854.76591878', w='558440.48801759', res='40')
	mg.run_command('v.surf.idw', input='nan_raingrass@PERMANENT', output='nan_idw', power='2', column='rain',flags='n', overwrite= True)
	#mg.run_command('v.surf.idw', input=inputs["idw_vect"] ["value"], output=inputs["idw_rast"] ["value"], power='2', column='rain',flags='n', overwrite= True)
	#mg.run_command('v.surf.idw', input=inputs["idw_vect"] ["value"], output=inputs["idw_rast"] ["value"], power=inputs["idw_power"] ["value"], column=inputs["idw_column"] ["value"],flags='n', overwrite= True)
	
	# Genarate Contour line (isolines)
	#mg.run_command('r.contour', input='rainthai_idw@PERMANENT', output='rain_isoline', step='5', overwrite= True)
	
	# Export rain_idw gdal to GeoTiff file and timestamp
	#mg.run_command('r.out.gdal', input='nan_idw@PERMANENT', type='Float64', output= path+'nanrainf_'+t+'.tif') #, overwrite= True
	#mg.run_command('r.out.gdal', input=inputs["idw_rast"] ["value"], type='Float64', output= inputs["dsn_export"] ["value"]+'_nanrain_'+t+'.tif') #, overwrite= True
	#mg.run_command('r.out.gdal', input='nan_idw@PERMANENT', type='Float64', output= path+'nanrainf.tif', overwrite= True)
	#mg.run_command('r.out.gdal', input='nan_idw@PERMANENT', type='Float64', output= path+'nanrainf_'+t+'.tif') #, overwrite= True
	
	# test mapcal runoff nanbasin
	# r.mapcalc nrunoff = ( pow( ( nan_idw@PERMANENT - ( 0.2 * grid_s@PERMANENT ) )  ,2 ) ) / ( nan_idw@PERMANENT + ( 0.8 * grid_s@PERMANENT ) )
	mg.write_command('r.mapcalc', stdin= 'nrunoff = ( pow( ( nan_idw@PERMANENT - ( 0.2 * grid_s@PERMANENT ) )  ,2 ) ) / ( nan_idw@PERMANENT + ( 0.8 * grid_s@PERMANENT ) )')
	
	mg.write_command('r.mapcalc', stdin= 'nrunoff_sqm3rai = (nrunoff@PERMANENT/1000)*1600')
	# to raster runoff output
	#mg.run_command('r.out.gdal', input=inputs["nrunoff"] ["value"], type='Float64', output= inputs["dsn_export"] ["value"]+'_runoff_'+t+'.tif') #, overwrite= True
	mg.run_command('r.out.gdal', input='nrunoff_sqm3rai@PERMANENT', type='Float64', output= path+'nanrunoff.tif', overwrite= True)
	
	# to vector
	#mg.run_command('r.to.vect', input='raincal@PERMANENT', output='warnings', feature='area', overwrite= True)
	
	
	# remove rast
	#mg.run_command('g.remove', rast='rainthai_idw@PERMANENT',quiet= True)
	
	#connection = psycopg2.connect(dbname='nanrunf', host='localhost', port='5432', user='******', password='******')
	#res = connection.cursor()
	#res.execute("DROP VIEW IF EXISTS _villrisk ;")
	#res.execute("DROP VIEW IF EXISTS vill_warn ;")
	#res.execute("DROP TABLE IF EXISTS warnings ;")
	#connection.commit()
	
	# Export warnning areas into PostgreSQL/PostGIS
	#v.out.ogr input=rain_isoline@PERMANENT type=line dsn=PG:host=localhost dbname=rain user=user olayer=rain_isoline format=PostgreSQL
	#mg.run_command('v.out.ogr', input='warnings@PERMANENT', type='area', dsn='PG:dbname=nanrunf', olayer='warnings', format='PostgreSQL',overwrite= True) #,flags='u',lco="OVERWRITE=YES"
	#mg.run_command('v.out.ogr', input='warnings@PERMANENT', type='area', flags='c', dsn='PG:host=localhost dbname=nanrunf user=user password=user', olayer='warnings', format='PostgreSQL')	
	
	#mg.run_command('v.delaunay', input='archsites',output='test_delaunay') 
	
	# Create Voronoi from Rain Station
	#v.voronoi input=rainthai_f@PERMANENT output=rain_voronoi --overwrite
	#mg.run_command('v.voronoi', input='rainthai_f@PERMANENT',output='rain_voronoi', overwrite= True) 
	
	#mg.run_command('v.out.ogr', input='rain_voronoi@PERMANENT', type='area', dsn='PG:dbname=rain', olayer='rain_voronoi', format='PostgreSQL',overwrite= True) #,flags='u'
	
# 	connection = psycopg2.connect(dbname='nanrunf', host='localhost', port='5432', user='******', password='******')
# 	res = connection.cursor()
# 	res.execute("DROP VIEW IF EXISTS _villrisk ;")
# 	res.execute("DROP VIEW IF EXISTS vill_warn ;")
# 	res.execute("DROP TABLE IF EXISTS warnings ;")
# 	res.execute("CREATE VIEW vill_warn AS SELECT v.gid, v.vill_code, v.vill_nam_t, v.geom FROM village_nbasin v, warnings w WHERE ST_Within (v.geom,w.wkb_geometry);")
# 	res.execute("CREATE VIEW _villrisk AS SELECT vw.gid, vw.vill_code, vw.vill_nam_t, vw.geom FROM vill_warn vw, landslide ls WHERE ST_Within (vw.geom,ls.geom);")
# 	connection.commit()
	
	outputs["Result"]["value"]=\
	"--> start process by: "+inputs["name"] ["value"]+ " --> Nan runoff processing successfully"
	
	return 3
def main():
    options, flags = gcore.parser()
    aspect = options['aspect']
    speed = options['speed']
    probability = options['probability']
    if options['particle_base']:
        particle_base = options['particle_base'] + '_'
    else:
        particle_base = None
    if options['particles']:
        particles = options['particles']
        min_size = float(options['min_size'])
        max_size = float(options['max_size'])
        comet_length = int(options['comet_length'])
    else:
        particles = min_size = max_size = comet_length = None
    try:
        total_time = int(options['total_time'])
        step = int(options['step'])
        age = int(options['age'])
        count = int(options['count'])
    except ValueError:
        gcore.fatal(_("Parameter should be integer"))

    gcore.use_temp_region()

    # create aspect in x and y direction
    aspect_x = 'aspect_x_' + str(os.getpid())
    aspect_y = 'aspect_y_' + str(os.getpid())
    xshift_tmp = 'xshift_tmp_' + str(os.getpid())
    yshift_tmp = 'yshift_tmp_' + str(os.getpid())
    TMP_RAST.append(aspect_x)
    TMP_RAST.append(aspect_y)
    grast.mapcalc(exp="{aspect_x} = cos({aspect})".format(aspect_x=aspect_x, aspect=aspect))
    grast.mapcalc(exp="{aspect_y} = sin({aspect})".format(aspect_y=aspect_y, aspect=aspect))
    grast.mapcalc(exp="{xshift} = {aspect_x}*{speed}*{t}".format(xshift=xshift_tmp, t=step, speed=speed,
                                                                 aspect_x=aspect_x), overwrite=True)
    grast.mapcalc(exp="{yshift} = {aspect_y}*{speed}*{t}".format(yshift=yshift_tmp, t=step, speed=speed,
                                                                 aspect_y=aspect_y), overwrite=True)

    # initialize
    vector_tmp1 = 'vector_tmp1_' + str(os.getpid())
    vector_tmp2 = 'vector_tmp2_' + str(os.getpid())
    vector_tmp3 = 'vector_tmp3_' + str(os.getpid())
    vector_region = 'vector_region_' + str(os.getpid())
    TMP_VECT.extend([vector_tmp1, vector_tmp2, vector_tmp3, vector_region])
    random_tmp = 'random_tmp_' + str(os.getpid())
    TMP_RAST.extend([xshift_tmp, yshift_tmp, random_tmp])
    gcore.run_command('v.in.region', output=vector_region, type='area')

    loop = 0
    vector_1 = particle_base + "{0:03d}".format(loop)
    generate_points(name=vector_1, probability_map=probability, count=count)

    grast.mapcalc(exp="{random} = int(rand(1, {maxt}))".format(random=random_tmp, maxt=age + 1))
    gcore.run_command('v.what.rast', map=vector_1, raster=random_tmp, column='t')
    write_vect_history('v.particles', options, flags, vector_1)
    vector_names = [vector_1, ]
    for time in range(0, total_time + step, step):
        vector_1 = particle_base + "{0:03d}".format(loop)
        vector_2 = particle_base + "{0:03d}".format(loop + 1)
        vector_names.append(vector_2)

        gcore.run_command('v.what.rast', map=vector_1, raster=xshift_tmp, column='xshift')
        gcore.run_command('v.what.rast', map=vector_1, raster=yshift_tmp, column='yshift')
        gcore.run_command('v.transform', layer=1, input=vector_1, output=vector_2,
                          columns='xshift:xshift,yshift:yshift', quiet=True)
        # increase age
        gcore.info("Increasing age...")
        sql = 'UPDATE {table} SET t=t+1;'.format(table=vector_2)
        gcore.run_command('db.execute', sql=sql)

        # remove old points
        gcore.info("Removing old points...")
        gcore.run_command('v.select', overwrite=True, ainput=vector_2, atype='point',
                          binput=vector_region, btype='area', operator='within', output=vector_tmp1)
        gcore.run_command('v.extract', input=vector_tmp1, layer=1, type='point',
                          where="t <= " + str(age) + " AND xshift IS NOT NULL", output=vector_tmp2, overwrite=True)

        # generate new points
        gcore.info("Generating new points...")
        count_to_generate = count - gvect.vector_info(vector_tmp2)['points']
        if count_to_generate > 0:
            generate_points(name=vector_tmp3, probability_map=probability,
                            count=count_to_generate, overwrite=True)

            gcore.info("Patchig new and old points...")
            gcore.run_command('v.patch', flags='e', input=[vector_tmp2, vector_tmp3],
                              output=vector_2, overwrite=True)
            sql = 'UPDATE {table} SET t={t} WHERE t IS NULL;'.format(table=vector_2, t=0)
            gcore.run_command('db.execute', sql=sql)
            
        write_vect_history('v.particles', options, flags, vector_2)

        loop += 1
    # Make sure the temporal database exists
    tgis.init()

    tgis.open_new_space_time_dataset(particle_base[:-1], type='stvds',
                                     temporaltype='relative',
                                     title="title", descr='desc',
                                     semantic='mean', dbif=None,
                                     overwrite=gcore.overwrite())
    # TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
    tgis.register_maps_in_space_time_dataset(
        type='vect', name=particle_base[:-1], maps=','.join(vector_names),
        start=str(1), end=None, unit='seconds', increment=step,
        interval=False, dbif=None)
        
    # create one vector map with multiple layers
    fd, path = tempfile.mkstemp(text=True)
    tmpfile = open(path, 'w')
    k = 0
    for vector in vector_names:
        k += 1
        layers = [x for x in range(k - comet_length + 1, k + 1) if x > 0]
        categories = list(range(len(layers), 0, -1))
        text = ''
        for layer, cat in zip(layers, categories):
            text += '{l} {c}\n'.format(l=layer, c=cat)
        coords = gcore.read_command('v.to.db', flags='p', quiet=True, map=vector,
                                    type='point', option='coor', separator=" ").strip()
        for coord in coords.split('\n'):
            coord = coord.split()
            tmpfile.write('P 1 {n_cat}\n{x} {y}\n'.format(n_cat=len(categories), x=coord[1], y=coord[2]))
            tmpfile.write(text)
    tmpfile.close()

    gcore.run_command('v.in.ascii', flags='n', overwrite=True, input=path, output=particles,
                      format='standard', separator=" ")
    os.close(fd)
    os.remove(path)
    k = 0
    sql = []
    sizes = get_sizes(max_size, min_size, comet_length)
    temporal_maps = []
    for vector in vector_names:
        k += 1
        table = 't' + str(k)
        gcore.run_command('v.db.addtable', map=particles, table=table, layer=k,
                          column="width double precision")
        temporal_maps.append(particles + ':' + str(k))
        for i in range(comet_length):
            sql.append("UPDATE {table} SET width={w:.1f} WHERE cat={c}".format(table=table,
                                                                               w=sizes[i][1], c=sizes[i][0]))
    gcore.write_command('db.execute', input='-', stdin=';\n'.join(sql))

    tgis.open_new_space_time_dataset(particles, type='stvds',
                                     temporaltype='relative',
                                     title="title", descr='desc',
                                     semantic='mean', dbif=None,
                                     overwrite=True)
    # TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
    tgis.register_maps_in_space_time_dataset(
        type='vect', name=particles, maps=','.join(temporal_maps),
        start=str(1), end=None, unit='seconds', increment=step,
        interval=False, dbif=None)

    write_vect_history('v.particles', options, flags, particles)
Beispiel #26
0
def main():
    layers = options['map'].split(',')

    if len(layers) < 2:
        grass.error(_("At least 2 maps are required"))

    tmpfile = grass.tempfile()

    for map in layers:
        if not grass.find_file(map, element='cell')['file']:
            grass.fatal(_("Raster map <%s> not found") % map)

    grass.write_command('d.text',
                        color='black',
                        size=4,
                        line=1,
                        stdin="CORRELATION")

    os.environ['GRASS_PNG_READ'] = 'TRUE'

    colors = "red black blue green gray violet".split()
    line = 2
    iloop = 0
    jloop = 0
    for iloop, i in enumerate(layers):
        for jloop, j in enumerate(layers):
            if i != j and iloop <= jloop:
                color = colors[0]
                colors = colors[1:]
                colors.append(color)
                grass.write_command('d.text',
                                    color=color,
                                    size=4,
                                    line=line,
                                    stdin="%s %s" % (i, j))
                line += 1

                ofile = file(tmpfile, 'w')
                grass.run_command('r.stats',
                                  flags='cnA',
                                  input=(i, j),
                                  stdout=ofile)
                ofile.close()

                ifile = file(tmpfile, 'r')
                first = True
                for l in ifile:
                    f = l.rstrip('\r\n').split(' ')
                    x = float(f[0])
                    y = float(f[1])
                    if first:
                        minx = maxx = x
                        miny = maxy = y
                        first = False
                    if minx > x: minx = x
                    if maxx < x: maxx = x
                    if miny > y: miny = y
                    if maxy < y: maxy = y
                ifile.close()

                kx = 100.0 / (maxx - minx + 1)
                ky = 100.0 / (maxy - miny + 1)

                p = grass.feed_command('d.graph', color=color)
                ofile = p.stdin

                ifile = file(tmpfile, 'r')
                for l in ifile:
                    f = l.rstrip('\r\n').split(' ')
                    x = float(f[0])
                    y = float(f[1])
                    ofile.write("icon + 0.1 %f %f\n" % ((x - minx + 1) * kx,
                                                        (y - miny + 1) * ky))
                ifile.close()

                ofile.close()
                p.wait()

    try_remove(tmpfile)
Beispiel #27
0
def nanlandslide(conf, inputs, outputs):

    # Set path result rain idw method
    path = '/var/www/html/dl/data/nanrainfall/'
    #path = '/usr/local/lib/geoserver-2.5/data_dir/coverages/result_data/'
    #path = '/var/lib/tomcat6/webapps/geoserver/data/coverages/result_data/'
    #path2 = '/home/user/data/chai/rasters/'
    t = time.strftime("%Y%m%d:%H%M%S")
    print t + "=> Hello times it work[200]!"
    connection = psycopg2.connect(dbname='nanrunf',
                                  host='localhost',
                                  port='5432',
                                  user='******',
                                  password='******')

    # Import point rainfall data from PostgreSQL/PostGIS
    mg.run_command('v.in.ogr',
                   dsn='PG:dbname=nanrunf',
                   layer='nan_raingrass',
                   output='nan_raingrass',
                   overwrite=True)

    # Set Extent and Interpolation IDW Method
    #mg.run_command('g.region', rast='rainthai_idw@PERMANENT',res='1000', quiet= True)
    mg.run_command('g.region',
                   n='2172120.86468637',
                   e='748094.237955',
                   s='1735854.76591878',
                   w='558440.48801759',
                   res='40')
    #mg.run_command('v.surf.idw', input='nan_raingrass@PERMANENT', output='nan_idw', power='2', column='rain',flags='n', overwrite= True)
    #mg.run_command('v.surf.idw', input=inputs["idw_vect"] ["value"], output=inputs["idw_rast"] ["value"], power='2', column='rain',flags='n', overwrite= True)
    mg.run_command('v.surf.idw',
                   input=inputs["idw_vect"]["value"],
                   output=inputs["idw_rast"]["value"],
                   power=inputs["idw_power"]["value"],
                   column=inputs["idw_column"]["value"],
                   flags='n',
                   overwrite=True)

    # Genarate Contour line (isolines)
    #mg.run_command('r.contour', input='rainthai_idw@PERMANENT', output='rain_isoline', step='5', overwrite= True)

    # Export rain_idw gdal to GeoTiff file and timestamp
    #mg.run_command('r.out.gdal', input='nan_idw@PERMANENT', type='Float64', output= path+'nanrainf_'+t+'.tif') #, overwrite= True
    mg.run_command('r.out.gdal',
                   input=inputs["idw_rast"]["value"],
                   type='Float64',
                   output=inputs["dsn_export"]["value"] + '_nanrain_' + t +
                   '.tif')  #, overwrite= True
    mg.run_command('r.out.gdal',
                   input='nan_idw@PERMANENT',
                   type='Float64',
                   output=path + 'nanrainf.tif',
                   overwrite=True)
    #mg.run_command('r.out.gdal', input='nan_idw@PERMANENT', type='Float64', output= path+'nanrainf_'+t+'.tif') #, overwrite= True

    # test mapcal
    mg.write_command('r.mapcalc',
                     stdin='raincal = if(nan_idw@PERMANENT > 25,1 ,null())')

    # to vector
    mg.run_command('r.to.vect',
                   input='raincal@PERMANENT',
                   output='warnings',
                   feature='area',
                   overwrite=True)

    # remove rast
    #mg.run_command('g.remove', rast='rainthai_idw@PERMANENT',quiet= True)

    connection = psycopg2.connect(dbname='nanrunf',
                                  host='localhost',
                                  port='5432',
                                  user='******',
                                  password='******')
    res = connection.cursor()
    res.execute("DROP VIEW IF EXISTS _villrisk ;")
    res.execute("DROP VIEW IF EXISTS vill_warn ;")
    res.execute("DROP TABLE IF EXISTS warnings ;")
    connection.commit()

    # Export warnning areas into PostgreSQL/PostGIS
    #v.out.ogr input=rain_isoline@PERMANENT type=line dsn=PG:host=localhost dbname=rain user=user olayer=rain_isoline format=PostgreSQL
    #mg.run_command('v.out.ogr', input='warnings@PERMANENT', type='area', dsn='PG:dbname=nanrunf', olayer='warnings', format='PostgreSQL',overwrite= True) #,flags='u',lco="OVERWRITE=YES"
    mg.run_command(
        'v.out.ogr',
        input='warnings@PERMANENT',
        type='area',
        flags='c',
        dsn='PG:host=localhost dbname=nanrunf user=user password=user',
        olayer='warnings',
        format='PostgreSQL')

    #mg.run_command('v.delaunay', input='archsites',output='test_delaunay')

    # Create Voronoi from Rain Station
    #v.voronoi input=rainthai_f@PERMANENT output=rain_voronoi --overwrite
    #mg.run_command('v.voronoi', input='rainthai_f@PERMANENT',output='rain_voronoi', overwrite= True)

    #mg.run_command('v.out.ogr', input='rain_voronoi@PERMANENT', type='area', dsn='PG:dbname=rain', olayer='rain_voronoi', format='PostgreSQL',overwrite= True) #,flags='u'

    connection = psycopg2.connect(dbname='nanrunf',
                                  host='localhost',
                                  port='5432',
                                  user='******',
                                  password='******')
    res = connection.cursor()
    # 	res.execute("DROP VIEW IF EXISTS _villrisk ;")
    # 	res.execute("DROP VIEW IF EXISTS vill_warn ;")
    # 	res.execute("DROP TABLE IF EXISTS warnings ;")
    res.execute(
        "CREATE VIEW vill_warn AS SELECT v.gid, v.vill_code, v.vill_nam_t, v.geom FROM village_nbasin v, warnings w WHERE ST_Within (v.geom,w.wkb_geometry);"
    )
    res.execute(
        "CREATE VIEW _villrisk AS SELECT vw.gid, vw.vill_code, vw.vill_nam_t, vw.geom FROM vill_warn vw, landslide ls WHERE ST_Within (vw.geom,ls.geom);"
    )
    connection.commit()

    outputs["Result"]["value"]=\
    "=> start process by: "+inputs["name"] ["value"]+ " | idw_inputvect: "+inputs["idw_vect"] ["value"]+ " | idw_outputrast: "+inputs["idw_rast"] ["value"]+ " | idw_power: "+inputs["idw_power"] ["value"]+ " | idw_column: "+inputs["idw_column"] ["value"]+ " | export_rast: "+inputs["dsn_export"] ["value"]

    return 3
Beispiel #28
0
def main():
    layers = options['map'].split(',')

    if len(layers) < 2:
	grass.error(_("At least 2 maps are required"))

    tmpfile = grass.tempfile()

    for map in layers:
	if not grass.find_file(map, element = 'cell')['file']:
	    grass.fatal(_("Raster map <%s> not found") % map)

    grass.write_command('d.text', color = 'black', size = 4, line = 1, stdin = "CORRELATION")

    os.environ['GRASS_PNG_READ'] = 'TRUE'

    colors = "red black blue green gray violet".split()
    line = 2
    iloop = 0
    jloop = 0
    for iloop, i in enumerate(layers):
	for jloop, j in enumerate(layers):
	    if i != j and iloop <= jloop:
		color = colors[0]
		colors = colors[1:]
		colors.append(color)
		grass.write_command('d.text', color = color, size = 4, line = line, stdin = "%s %s" % (i, j))
		line += 1

		ofile = file(tmpfile, 'w')
		grass.run_command('r.stats', flags = 'cnA', input = (i, j), stdout = ofile)
		ofile.close()

		ifile = file(tmpfile, 'r')
		first = True
		for l in ifile:
		    f = l.rstrip('\r\n').split(' ')
		    x = float(f[0])
		    y = float(f[1])
		    if first:
			minx = maxx = x
			miny = maxy = y
			first = False
		    if minx > x: minx = x
		    if maxx < x: maxx = x
		    if miny > y: miny = y
		    if maxy < y: maxy = y
		ifile.close()

		kx = 100.0/(maxx-minx+1)
		ky = 100.0/(maxy-miny+1)

		p = grass.feed_command('d.graph', color = color)
		ofile = p.stdin

		ifile = file(tmpfile, 'r')
		for l in ifile:
		    f = l.rstrip('\r\n').split(' ')
		    x = float(f[0])
		    y = float(f[1])
		    ofile.write("icon + 0.1 %f %f\n" % ((x-minx+1) * kx, (y-miny+1) * ky))
		ifile.close()

		ofile.close()
		p.wait()

    grass.try_remove(tmpfile)
  grass.run_command('v.db.addtable', map=pplocs[i], col="cat int, Accumulation double precision, Discharge double precision")

for i in range(len(ages)-1):
  grass.run_command('g.copy', vect=pplocs[i] + ',tmp', overwrite=True)
  grass.run_command('v.category', input='tmp', output=pplocs[i], overwrite=True)
  
for i in range(len(ages)-1):
  grass.run_command('v.to.db', map=pplocs[i], columns="cat", option="cat", type='point')
  
for i in range(len(ages)-1):
  print ages[i]
  grass.run_command('v.what.rast', vect=pplocs[i], rast=accumulation[i], col='Accumulation', layer=1)

for i in range(len(ages)-1):
  print ages[i]
  grass.write_command('db.execute', stdin = "UPDATE " + pplocs[i] + " SET Discharge=Accumulation/1000" )


# As well as discharges at confluences
for i in range(len(ages)-1):
  print ages[i]
  grass.run_command('v.db.addcol', map=tributary_junctions[i], col="Discharge double precision")

for i in range(len(ages)-1):
  print ages[i]
  grass.write_command('db.execute', stdin = "UPDATE " + tributary_junctions[i] + " SET Discharge=Accumulation/1000" )



# After this, need to create a set of points on all of the channel segments.
# These points will contain flow direction and discharge, allowing me to map 
Beispiel #30
0
def main():
    indb = options["database"]
    prefix = options["basename"]
    env = grass.gisenv()
    # fix sqlite3 db field string multibyte character problem
    sys.setdefaultencoding("utf-8")
    # check if 3d or not
    if flags["z"]:
        d3 = "z"
    else:
        d3 = ""
    owrite = grass.overwrite()
    # check if location it is latlong
    if grass.locn_is_latlong():
        locn = True
    else:
        locn = False
    # connection to sqlite geopaparazzi database
    import sqlite3

    conn = sqlite3.connect(indb)
    curs = conn.cursor()
    # if it is not a latlong location create a latlong location on the fly
    if not locn:
        # create new location and move to it creating new gisrc file
        new_loc = basename(grass.tempfile(create=False))
        new_loc_name = "geopaparazzi_%s" % new_loc
        grass.create_location(
            dbase=env["GISDBASE"],
            epsg="4326",
            location=new_loc_name,
            desc="Temporary location for v.in.geopaparazzi",
        )
        grc = os.getenv("GISRC")
        shutil.copyfile(grc, grc + ".old")
        newrc = open(grc, "w")
        newrc.write("GISDBASE: %s\n" % env["GISDBASE"])
        newrc.write("LOCATION_NAME: %s\n" % new_loc_name)
        newrc.write("MAPSET: PERMANENT\n")
        newrc.write("GRASS_GUI: text\n")
        newrc.close()
        grass.run_command("db.connect", flags="d", quiet=True)

    # load bookmarks
    if flags["b"]:
        # check if elements in bookmarks table are more the 0
        if checkEle(curs, "bookmarks") != 0:
            bookname = prefix + "_book"
            pois = importGeom(bookname, "bookmarks", curs, owrite, "")
            sql = "CREATE TABLE %s (cat int, text text)" % bookname
            grass.write_command("db.execute", input="-", stdin=sql)
            # select attributes
            sql = "select text from bookmarks order by _id"
            allattri = returnClear(curs, sql)
            # add values using insert statement
            idcat = 1
            for row in allattri:
                values = "%d,'%s'" % (idcat, str(row))
                sql = "insert into %s values(%s)" % (bookname, values)
                grass.write_command("db.execute", input="-", stdin=sql)
                idcat += 1
            # at the end connect table to vector
            grass.run_command("v.db.connect", map=bookname, table=bookname, quiet=True)
        else:
            grass.warning(_("No bookmarks found, escape them"))
    # load images
    if flags["i"]:
        # check if elements in images table are more the 0
        if checkEle(curs, "images") != 0:
            imagename = prefix + "_image"
            pois = importGeom(imagename, "images", curs, owrite, d3)
            sql = "CREATE TABLE %s (cat int, azim int, " % imagename
            sql += "path text, ts text, text text)"
            grass.write_command("db.execute", input="-", stdin=sql)
            # select attributes
            sql = "select azim, path, ts, text from images order by _id"
            allattri = returnAll(curs, sql)
            # add values using insert statement
            idcat = 1
            for row in allattri:
                values = "%d,'%d','%s','%s','%s'" % (
                    idcat,
                    row[0],
                    str(row[1]),
                    str(row[2]),
                    str(row[3]),
                )
                sql = "insert into %s values(%s)" % (imagename, values)
                grass.write_command("db.execute", input="-", stdin=sql)
                idcat += 1
            # at the end connect table to vector
            grass.run_command(
                "v.db.connect", map=imagename, table=imagename, quiet=True
            )
        else:
            grass.warning(_("No images found, escape them"))
    # if tracks or nodes should be imported create a connection with sqlite3
    # load notes
    if flags["n"]:
        # check if elements in notes table are more the 0
        if checkEle(curs, "notes") != 0:
            # select each categories
            categories = returnClear(curs, "select cat from notes group by cat")
            # for each category
            for cat in categories:
                # select lat, lon for create point layer
                catname = prefix + "_notes_" + cat
                pois = importGeom(catname, "notes", curs, owrite, d3, cat)
                # select form to understand the number
                forms = returnClear(
                    curs,
                    "select _id from notes where cat = '%s' "
                    "and form is not null order by _id" % cat,
                )
                # if number of form is different from 0 and number of point
                # remove the vector because some form it is different
                if len(forms) != 0 and len(forms) != len(pois):
                    grass.run_command(
                        "g.remove", flags="f", type="vector", name=catname, quiet=True
                    )
                    grass.warning(
                        _(
                            "Vector %s not imported because number"
                            " of points and form is different"
                        )
                    )
                # if form it's 0 there is no form
                elif len(forms) == 0:
                    # create table without form
                    sql = "CREATE TABLE %s (cat int, ts text, " % catname
                    sql += "text text, geopap_cat text)"
                    grass.write_command("db.execute", input="-", stdin=sql)
                    # select attributes
                    sql = (
                        "select ts, text, cat from notes where "
                        "cat='%s' order by _id" % cat
                    )
                    allattri = returnAll(curs, sql)
                    # add values using insert statement
                    idcat = 1
                    for row in allattri:
                        values = "%d,'%s','%s','%s'" % (
                            idcat,
                            str(row[0]),
                            str(row[1]),
                            str(row[2]),
                        )
                        sql = "insert into %s values(%s)" % (catname, values)
                        grass.write_command("db.execute", input="-", stdin=sql)
                        idcat += 1
                    # at the end connect table to vector
                    grass.run_command(
                        "v.db.connect", map=catname, table=catname, quiet=True
                    )
                # create table with form
                else:
                    # select all the attribute
                    sql = (
                        "select ts, text, cat, form from notes where "
                        "cat='%s' order by _id" % cat
                    )
                    allattri = returnAll(curs, sql)
                    # return string of form's categories too create table
                    keys = returnFormKeys(allattri)
                    sql = "CREATE TABLE %s (cat int, ts text, " % catname
                    sql += "text text, geopap_cat text %s)" % keys
                    grass.write_command("db.execute", input="-", stdin=sql)
                    # it's for the number of categories
                    idcat = 1
                    # for each feature insert value
                    for row in allattri:
                        values = "%d,'%s','%s','%s'," % (
                            idcat,
                            str(row[0]),
                            str(row[1]),
                            str(row[2]),
                        )
                        values += returnFormValues(row[3])
                        sql = "insert into %s values(%s)" % (catname, values)
                        grass.write_command("db.execute", input="-", stdin=sql)
                        idcat += 1
                    # at the end connect table with vector
                    grass.run_command(
                        "v.db.connect", map=catname, table=catname, quiet=True
                    )
        else:
            grass.warning(_("No notes found, escape them"))
    # load tracks
    if flags["t"]:
        # check if elements in bookmarks table are more the 0
        if checkEle(curs, "gpslogs") != 0:
            tracksname = prefix + "_tracks"
            # define string for insert data at the end
            tracks = ""
            # return ids of tracks
            ids = returnClear(curs, "select _id from gpslogs")
            # for each track
            for i in ids:
                # select all the points coordinates
                tsel = "select lon, lat"
                if flags["z"]:
                    tsel += ", altim"
                tsel += " from gpslog_data where logid=%s order by _id" % i
                trackpoints = returnAll(curs, tsel)
                wpoi = "\n".join(
                    ["|".join([str(col) for col in row]) for row in trackpoints]
                )
                tracks += "%s\n" % wpoi
                if flags["z"]:
                    tracks += "NaN|NaN|Nan\n"
                else:
                    tracks += "NaN|Nan\n"
            # import lines
            try:
                grass.write_command(
                    "v.in.lines",
                    flags=d3,
                    input="-",
                    out=tracksname,
                    stdin=tracks,
                    overwrite=owrite,
                    quiet=True,
                )
            except CalledModuleError:
                grass.fatal(_("Error importing %s" % tracksname))
            # create table for line
            sql = "CREATE TABLE %s (cat int, startts text, " % tracksname
            sql += "endts text, text text, color text, width int)"
            grass.write_command("db.execute", input="-", stdin=sql)
            sql = (
                "select logid, startts, endts, text, color, width from"
                " gpslogs, gpslogsproperties where gpslogs._id="
                "gpslogsproperties.logid"
            )
            # return attributes
            allattri = returnAll(curs, sql)
            # for each line insert attribute
            for row in allattri:
                values = "%d,'%s','%s','%s','%s',%d" % (
                    row[0],
                    str(row[1]),
                    str(row[2]),
                    str(row[3]),
                    str(row[4]),
                    row[5],
                )
                sql = "insert into %s values(%s)" % (tracksname, values)
                grass.write_command("db.execute", input="-", stdin=sql)
            # at the end connect map with table
            grass.run_command(
                "v.db.connect", map=tracksname, table=tracksname, quiet=True
            )
        else:
            grass.warning(_("No tracks found, escape them"))
    # if location it's not latlong reproject it
    if not locn:
        # copy restore the original location
        shutil.copyfile(grc + ".old", grc)
        # reproject bookmarks
        if flags["b"] and checkEle(curs, "bookmarks") != 0:
            grass.run_command(
                "v.proj",
                quiet=True,
                input=bookname,
                location="geopaparazzi_%s" % new_loc,
                mapset="PERMANENT",
            )
        # reproject images
        if flags["i"] and checkEle(curs, "images") != 0:
            grass.run_command(
                "v.proj",
                quiet=True,
                input=imagename,
                location="geopaparazzi_%s" % new_loc,
                mapset="PERMANENT",
            )
        # reproject notes
        if flags["n"] and checkEle(curs, "notes") != 0:
            for cat in categories:
                catname = prefix + "_node_" + cat
                grass.run_command(
                    "v.proj",
                    quiet=True,
                    input=catname,
                    location="geopaparazzi_%s" % new_loc,
                    mapset="PERMANENT",
                )
        # reproject track
        if flags["t"] and checkEle(curs, "gpslogs") != 0:
            grass.run_command(
                "v.proj",
                quiet=True,
                input=tracksname,
                location="geopaparazzi_%s" % new_loc,
                mapset="PERMANENT",
            )
Beispiel #31
0
def simulate_fire(params, simulation_intervals, data_indexes, outputs):
    """
    n = ['a' , 'b', 'c']
    o = ['i' , 'j', 'k', 'l']
    params = FireSimulationParams(model='m', moistures_live=n, moistures_1h=n, moistures_10h=n, moistures_100h=n, wind_directions=n, wind_velocities=n, start_raster='x', slope='o', aspect='p', elevation='q')
    simulate_fire(params, [(0, 1), (1, 3), (3, 8), (8, 9)], [0, 1, 1, 2], o)
    """
    start_raster = params.start_raster
    # TODO: clean the tmp maps: g.mremove rast="rfirespread_rros_out*" -f
    # r.ros output raster maps (.base, .max, .maxdir, .spotdist)
    ros_basename = 'rfirespread_rros_out'
    ros_base = ros_basename + '.base'
    ros_max = ros_basename + '.max'
    ros_maxdir = ros_basename + '.maxdir'
    ros_spotdist = ros_basename + '.spotdist' if params.spotting else None
    rros_params = dict(model=params.model,
                       slope=params.slope,
                       aspect=params.aspect,
                       elevation=params.elevation,
                       base_ros=ros_base,
                       max_ros=ros_max,
                       direction_ros=ros_maxdir)
    if ros_spotdist:
        rros_params['spotting_distance'] = ros_spotdist
    rspread_params = dict(max_ros=ros_max,
                          direction_ros=ros_maxdir,
                          base_ros=ros_base)

    first_run = True
    for index, interval in enumerate(simulation_intervals):
        # print ">>>>>>>>>", index, interval, params.model, params.moistures_100h[data_indexes[index]], params.wind_directions[data_indexes[index]], params.wind_velocities[data_indexes[index]]
        # TODO: change the print to message
        rros_params['moisture_live'] = params.moistures_live[
            data_indexes[index]]
        if params.moistures_1h:
            rros_params['moisture_1h'] = params.moistures_1h[
                data_indexes[index]]
        if params.moistures_10h:
            rros_params['moisture_10h'] = params.moistures_10h[
                data_indexes[index]]
        if params.moistures_100h:
            rros_params['moisture_100h'] = params.moistures_100h[
                data_indexes[index]]
        if params.wind_directions:
            rros_params['direction'] = params.wind_directions[
                data_indexes[index]]
        if params.wind_velocities:
            rros_params['velocity'] = params.wind_velocities[
                data_indexes[index]]
        ret = run_command('r.ros', **rros_params)

        if ret != 0:
            gcore.fatal(_("r.ros failed. Please check above error messages."))
        if first_run:
            rspread_flags = ''
            first_run = False
        else:
            rspread_flags = 'i'
        if params.spotting:
            rspread_flags += 's'
            rspread_params['spotting_distance'] = ros_spotdist
            rspread_params['wind_speed'] = params.wind_velocities[
                data_indexes[index]]
            rspread_params['fuel_moisture'] = params.moistures_1h[
                data_indexes[index]]

        rspread_params.update(
            dict(start=start_raster,
                 output=outputs[index],
                 init_time=interval[0],
                 lag=interval[1] - interval[0]))
        ret = run_command('r.spread', flags=rspread_flags, **rspread_params)

        if ret != 0:
            gcore.fatal(
                _("r.spread failed. Please check above error messages."))
        rast_to_remove = [ros_base, ros_max, ros_maxdir]
        if params.spotting:
            rast_to_remove.append(ros_spotdist)
        ret = run_command('g.remove',
                          type='raster',
                          name=rast_to_remove,
                          flags='f')
        if ret != 0:
            gcore.fatal(
                _("g.remove failed when cleaning after r.ros and r.spread."
                  " This might mean the error of programmer or unexpected behavior of one of the modules."
                  " Please check above error messages."))
        ret = run_command('r.null', map=outputs[index], setnull=0)
        if ret != 0:
            gcore.fatal(_("r.null failed. Please check above error messages."))
        ret = write_command('r.colors',
                            map=outputs[index],
                            rules='-',
                            stdin="""
                            0% 50:50:50
                            60% yellow
                            100% red
                            """)
        if ret != 0:
            gcore.fatal(
                _("r.colors failed. Please check above error messages."))
        start_raster = outputs[index]
Beispiel #32
0
def main():
    layers = options["map"].split(",")

    if len(layers) < 2:
        gcore.error(_("At least 2 maps are required"))

    tmpfile = gcore.tempfile()

    for map in layers:
        if not gcore.find_file(map, element="cell")["file"]:
            gcore.fatal(_("Raster map <%s> not found") % map)

    try:
        gcore.write_command(
            "d.text", color="black", size=4, line=1, stdin="CORRELATION"
        )
    except CalledModuleError:
        return 1

    os.environ["GRASS_RENDER_FILE_READ"] = "TRUE"

    colors = "red black blue green gray violet".split()
    line = 2
    iloop = 0
    jloop = 0
    for iloop, i in enumerate(layers):
        for jloop, j in enumerate(layers):
            if i != j and iloop <= jloop:
                color = colors[0]
                colors = colors[1:]
                colors.append(color)
                gcore.write_command(
                    "d.text", color=color, size=4, line=line, stdin="%s %s" % (i, j)
                )
                line += 1

                ofile = open(tmpfile, "w")
                gcore.run_command("r.stats", flags="cnA", input=(i, j), stdout=ofile)
                ofile.close()

                ifile = open(tmpfile, "r")
                first = True
                for line in ifile:
                    f = line.rstrip("\r\n").split(" ")
                    x = float(f[0])
                    y = float(f[1])
                    if first:
                        minx = maxx = x
                        miny = maxy = y
                        first = False
                    if minx > x:
                        minx = x
                    if maxx < x:
                        maxx = x
                    if miny > y:
                        miny = y
                    if maxy < y:
                        maxy = y
                ifile.close()

                kx = 100.0 / (maxx - minx + 1)
                ky = 100.0 / (maxy - miny + 1)

                p = gcore.feed_command("d.graph", color=color)
                ofile = p.stdin

                ifile = open(tmpfile, "r")
                for line in ifile:
                    f = line.rstrip("\r\n").split(" ")
                    x = float(f[0])
                    y = float(f[1])
                    ofile.write(
                        b"icon + 0.1 %f %f\n"
                        % ((x - minx + 1) * kx, (y - miny + 1) * ky)
                    )
                ifile.close()

                ofile.close()
                p.wait()

    try_remove(tmpfile)

    return 0
Beispiel #33
0
def main(input_, coordinates, output, axes, slice_line, units, offset):
    prefix = 'r3_to_rast_tmp_' + str(os.getpid())
    gcore.run_command('r3.to.rast', input=input_, output=prefix)
    maps = gcore.read_command('g.list', type='raster', pattern=PREFIX + '*').strip().split(os.linesep)
    region = gcore.region(region3d=True)
    res = (region['ewres'] + region['nsres']) / 2.
    if coordinates[0][0] > coordinates[1][0]:
        coordinates = (coordinates[1], coordinates[0])
    profile = gcore.read_command('r.profile', coordinates=coordinates,
                                 input=maps[0], output='-').strip().split(os.linesep)
    cols = len(profile)
    rows = len(maps)
    s = w = 0
    e = cols * res
    n = rows * region['tbres']
    if offset:
        offset[0] = w + (e - w) * float(offset[0])
        offset[1] = (n - s) * float(offset[1])
        e += offset[0]
        w += offset[0]
        n += offset[1]
        s += offset[1]
    ascii_input = [("north: {n}\nsouth: {s}\neast: {e}\nwest: {w}\n"
                   "rows: {r}\ncols: {c}\n".format(n=n, s=s, e=e, w=w, r=rows, c=cols))]
    for map_ in reversed(maps):
        profile = gcore.read_command('r.profile', coordinates=coordinates,
                                     input=map_, output='-', quiet=True).strip().split(os.linesep)
        ascii_input.append(' '.join([line.split()[1] for line in profile]))

    gcore.write_command('r.in.ascii', input='-', stdin='\n'.join(ascii_input),
                        output=output, type='FCELL')

    gcore.run_command('r.colors', map=output, raster_3d=input_)

    if slice_line:
        vector_ascii = []
        vector_ascii.append('L 2 1')
        vector_ascii.append('{x} {y}'.format(x=coordinates[0][0], y=coordinates[0][1]))
        vector_ascii.append('{x} {y}'.format(x=coordinates[1][0], y=coordinates[1][1]))
        vector_ascii.append('1 1')
        gcore.write_command('v.in.ascii', format='standard', input='-', stdin='\n'.join(vector_ascii),
                            flags='n', output=slice_line)

    if axes:
        vector_ascii = []
        vector_ascii.append('L 2 1')
        vector_ascii.append('{x} {y}'.format(x=w, y=n + 0.1 * (n - s)))
        vector_ascii.append('{x} {y}'.format(x=e, y=n + 0.1 * (n - s)))
        vector_ascii.append('1 1')
        vector_ascii.append('P 1 1')
        vector_ascii.append('{x} {y}'.format(x=w, y=n + 0.1 * (n - s)))
        vector_ascii.append('2 1')
        vector_ascii.append('P 1 1')
        vector_ascii.append('{x} {y}'.format(x=e, y=n + 0.1 * (n - s)))
        vector_ascii.append('2 2')

        vector_ascii.append('L 2 1')
        vector_ascii.append('{x} {y}'.format(x=e + 0.05 * (e - w), y=n))
        vector_ascii.append('{x} {y}'.format(x=e + 0.05 * (e - w), y=s))
        vector_ascii.append('2 3')
        vector_ascii.append('P 1 1')
        vector_ascii.append('{x} {y}'.format(x=e + 0.05 * (e - w), y=n))
        vector_ascii.append('1 2')
        vector_ascii.append('P 1 1')
        vector_ascii.append('{x} {y}'.format(x=e + 0.05 * (e - w), y=s))
        vector_ascii.append('1 3')

        gcore.write_command('v.in.ascii', format='standard', input='-', stdin='\n'.join(vector_ascii),
                            flags='n', output=axes)
        if units:
            units = units.split(',')
        else:
            units = ['', '']
        gcore.run_command('v.db.addtable', map=axes, layer=1, columns="label varchar(50)")
        sql = ('UPDATE {axes} SET label = "{length} {u1}" WHERE cat = 1;\n'
               'UPDATE {axes} SET label = "{top} {u2}" WHERE cat = 2;\n'
               'UPDATE {axes} SET label = "{bottom} {u2}" WHERE cat = 3;\n'.format(axes=axes, length=int(e - w),
                                                                            top=region['t'], bottom=region['b'],
                                                                            u1=units[0], u2=units[1]))
        gcore.write_command('db.execute', input='-', stdin=sql)
Beispiel #34
0
        return
    array = trim_edges_nsew(array, trim_nsew)
    gcore.run_command('g.region', rast=real_elev)

    array = scale_subsurface_flat(real_elev, array, zexag, base=table_height, height_mm=37, info_text=info_text)
    # save resulting array
    np.savetxt(temp_path, array, delimiter=" ")

    # import
    tmp_regions = []
    env = get_environment(tmp_regions, n=np.max(array[:, 1]), s=np.min(array[:, 1]), e=np.max(array[:, 0]), w=np.min(array[:, 0]), res=mm_resolution)
    bin_surface(input_file=temp_path, output_raster=output_elev, temporary_raster=output_tmp1, env=env)

    adjust_boundaries(real_elev=real_elev, scanned_elev=output_elev, env=env)
    env = get_environment(tmp_regions, rast=output_elev)
    gcore.write_command('r.colors', map=output_elev, rules='-', stdin="0% 0:66:0\n100% 197:255:138")

#    gcore.run_command('r.colors', map=output_elev, color='elevation')
        

    difference(real_elev=real_elev, scanned_elev=output_elev, new='diff', env=env)

    env = get_environment(tmp_regions, rast3d=voxel, nsres=3, ewres=3)
#    voxels = gcore.read_command('g.mlist', quiet=True, type='rast3d', pattern='interp_2003*', separator=',').strip()
#    for voxel in voxels.split(','):
#        output_cross_ = output_cross + '2' + voxel
    cross_section(output_elev, voxel, output_cross, env=env)
    contours(scanned_elev=output_elev, new='scanned_contours', step=5., env=env)
#    cross_section_fill(output_elev, voxel, output_cross)
#    gcore.run_command('r3.cross.rast', input=voxel, elevation=output_elev, output=output_cross, overwrite=True)
Beispiel #35
0
def change_detection(before, after, change, height_threshold, cells_threshold,
                     add, max_detected, debug, env):
    diff_thr = 'diff_thr_' + str(uuid.uuid4()).replace('-', '')
    diff_thr_clump = 'diff_thr_clump_' + str(uuid.uuid4()).replace('-', '')
    coeff = gcore.parse_command('r.regression.line',
                                mapx=after,
                                mapy=before,
                                flags='g',
                                env=env)
    grast.mapcalc('diff = {a} + {b} * {after} - {before}'.format(a=coeff['a'],
                                                                 b=coeff['b'],
                                                                 before=before,
                                                                 after=after),
                  env=env)
    try:
        if add:
            grast.mapcalc(
                "{diff_thr} = if(({a} + {b} * {after} - {before}) > {thr1} &&"
                " ({a} + {b} * {after} - {before}) < {thr2}, 1, null())".
                format(a=coeff['a'],
                       b=coeff['b'],
                       diff_thr=diff_thr,
                       after=after,
                       before=before,
                       thr1=height_threshold[0],
                       thr2=height_threshold[1]),
                env=env)
        else:
            grast.mapcalc(
                "{diff_thr} = if(({before} - {a} + {b} * {after}) > {thr}, 1, null())"
                .format(diff_thr=diff_thr,
                        a=coeff['a'],
                        b=coeff['b'],
                        after=after,
                        before=before,
                        thr=height_threshold),
                env=env)

        gcore.run_command('r.clump',
                          input=diff_thr,
                          output=diff_thr_clump,
                          env=env)
        stats = gcore.read_command('r.stats',
                                   flags='cn',
                                   input=diff_thr_clump,
                                   sort='desc',
                                   env=env).strip().splitlines()
        if debug:
            print('DEBUG: {}'.format(stats))
        if len(stats) > 0 and stats[0]:
            cats = []
            found = 0
            for stat in stats:
                if found >= max_detected:
                    break
                if float(stat.split()[1]) < cells_threshold[1] and float(
                        stat.split()[1]) > cells_threshold[
                            0]:  # larger than specified number of cells
                    found += 1
                    cat, value = stat.split()
                    cats.append(cat)
            if cats:
                rules = ['{c}:{c}:1'.format(c=c) for c in cats]
                gcore.write_command('r.recode',
                                    input=diff_thr_clump,
                                    output=change,
                                    rules='-',
                                    stdin='\n'.join(rules),
                                    env=env)
                gcore.run_command('r.volume',
                                  flags='f',
                                  input=change,
                                  clump=diff_thr_clump,
                                  centroids=change,
                                  env=env)
            else:
                gcore.warning("No change found!")
                gcore.run_command('v.edit', map=change, tool='create', env=env)
        else:
            gcore.warning("No change found!")
            gcore.run_command('v.edit', map=change, tool='create', env=env)

        gcore.run_command('g.remove',
                          flags='f',
                          type=['raster'],
                          name=[diff_thr, diff_thr_clump],
                          env=env)
    except:
        gcore.run_command('g.remove',
                          flags='f',
                          type=['raster'],
                          name=[diff_thr, diff_thr_clump],
                          env=env)