예제 #1
0
    def compute(self):
        # computing
        grass.message('"nnbathy" is performing the interpolation now. \
                      This may take some time...')
        grass.verbose("Once it completes an 'All done.' \
                      message will be printed.")

        # nnbathy calling
        fsock = open(self._xyzout, "w")
        grass.call(
            [
                "nnbathy",
                "-W",
                "%d" % 0,
                "-i",
                "%s" % self._tmpxyz,
                "-x",
                "%f" % self.nn_w,
                "%f" % self.nn_e,
                "-y",
                "%f" % self.nn_n,
                "%f" % self.nn_s,
                "-P",
                "%s" % self.ALG,
                "-n",
                "%dx%d" % (self.cols, self.rows),
            ],
            stdout=fsock,
        )
        fsock.close()
예제 #2
0
def ppmtopng(dst, src):
    if grass.find_program("g.ppmtopng", "--help"):
        grass.run_command("g.ppmtopng", input=src, output=dst, quiet=True)
    elif grass.find_program("pnmtopng"):
        fh = open(dst, "wb")
        grass.call(["pnmtopng", src], stdout=fh)
        fh.close()
    elif grass.find_program("convert"):
        grass.call(["convert", src, dst])
    else:
        grass.fatal(_("Cannot find g.ppmtopng, pnmtopng or convert"))
예제 #3
0
def ppmtopng(dst, src):
    if grass.find_program("g.ppmtopng", '--help'):
        grass.run_command('g.ppmtopng', input = src, output = dst, quiet = True)
    elif grass.find_program("pnmtopng"):
        fh = open(dst, 'wb')
        grass.call(["pnmtopng", src], stdout = fh)
        fh.close()
    elif grass.find_program("convert"):
        grass.call(["convert", src, dst])
    else:
        grass.fatal(_("Cannot find g.ppmtopng, pnmtopng or convert"))
예제 #4
0
    def compute(self):
        # computing
        grass.message('"nnbathy" is performing the interpolation now. \
                      This may take some time...')
        grass.verbose("Once it completes an 'All done.' \
                      message will be printed.")

        # nnbathy calling
        fsock = open(self._xyzout, 'w')
        grass.call(['nnbathy',
                    '-W', '%d' % 0,
                    '-i', '%s' % self._tmpxyz,
                    '-x', '%d' % self.nn_w, '%d' % self.nn_e,
                    '-y', '%d' % self.nn_n, '%d' % self.nn_s,
                    '-P', '%s' % self.ALG,
                    '-n', '%dx%d' % (self.cols, self.rows)],
                   stdout=fsock)
        fsock.close()
예제 #5
0
    def compute(self):
        # computing
        grass.message('"nnbathy" is performing the interpolation now. \
                      This may take some time...')
        grass.verbose("Once it completes an 'All done.' \
                      message will be printed.")

        # nnbathy calling
        fsock = open(self._xyzout, 'w')
        grass.call([
            'nnbathy', '-W',
            '%d' % 0, '-i',
            '%s' % self._tmpxyz, '-x',
            '%f' % self.nn_w,
            '%f' % self.nn_e, '-y',
            '%f' % self.nn_n,
            '%f' % self.nn_s, '-P',
            '%s' % self.ALG, '-n',
            '%dx%d' % (self.cols, self.rows)
        ],
                   stdout=fsock)
        fsock.close()
예제 #6
0
def import_aster(proj, srcfile, tempfile, band):
    #run gdalwarp with selected options (must be in $PATH)
    #to translate aster image to geotiff
    grass.message(_("Georeferencing aster image ..."))
    grass.debug("gdalwarp -t_srs %s %s %s" % (proj, srcfile, tempfile))

    if platform.system() == "Darwin":
        cmd = ["arch", "-i386", "gdalwarp", "-t_srs", proj, srcfile, tempfile ]
    else:
        cmd = ["gdalwarp", "-t_srs", proj, srcfile, tempfile ]
    p = grass.call(cmd)
    if p != 0:
        #check to see if gdalwarp executed properly
        return

    #import geotiff to GRASS
    grass.message(_("Importing into GRASS ..."))
    outfile = "%s.%s" % (output, band)
    grass.run_command("r.in.gdal", input = tempfile, output = outfile)

    # write cmd history
    grass.raster_history(outfile)
예제 #7
0
def import_aster(proj, srcfile, tempfile, band):
    #run gdalwarp with selected options (must be in $PATH)
    #to translate aster image to geotiff
    grass.message(_("Georeferencing aster image ..."))
    grass.debug("gdalwarp -t_srs %s %s %s" % (proj, srcfile, tempfile))

    if platform.system() == "Darwin":
        cmd = ["arch", "-i386", "gdalwarp", "-t_srs", proj, srcfile, tempfile]
    else:
        cmd = ["gdalwarp", "-t_srs", proj, srcfile, tempfile]
    p = grass.call(cmd)
    if p != 0:
        #check to see if gdalwarp executed properly
        return

    #import geotiff to GRASS
    grass.message(_("Importing into GRASS ..."))
    outfile = "%s.%s" % (output, band)
    grass.run_command("r.in.gdal", input=tempfile, output=outfile)

    # write cmd history
    grass.raster_history(outfile)
예제 #8
0
def main():
    global tmp, tmp_proj, tmp_gpx, tmp_extr, tmp_vogb

    format = options['format']
    input = options['input']
    layer = options['layer']
    output = options['output']
    type = options['type']
    where = options['where']
    wpt = flags['w']
    rte = flags['r']
    trk = flags['t']

    nflags = len(filter(None, [wpt, rte, trk]))
    if nflags > 1:
	grass.fatal(_("One feature at a time please."))
    if nflags < 1:
	grass.fatal(_("No features requested for export."))

    # set some reasonable defaults
    if not type:
	if wpt:
	    type = 'point'
	else:
	    type = 'line'

    #### check for gpsbabel
    ### FIXME: may need --help or similar?
    if not grass.find_program("gpsbabel"):
	grass.fatal(_("The gpsbabel program was not found, please install it first.\n") +
		    "http://gpsbabel.sourceforge.net")

    #### check for cs2cs
    if not grass.find_program("cs2cs"):
	grass.fatal(_("The cs2cs program was not found, please install it first.\n") +
		    "http://proj.osgeo.org")

    # check if we will overwrite data
    if os.path.exists(output) and not grass.overwrite():
	grass.fatal(_("Output file already exists."))

    #### set temporary files
    tmp = grass.tempfile()

    # SQL extract if needed
    if where:
	grass.verbose("Extracting data ...")
	tmp_extr = "tmp_vogb_extr_%d" % os.getpid()
	ret = grass.run_command('v.extract', input = "$GIS_OPT_INPUT",
				output = tmp_extr, type = type, layer = layer,
				where = where, quiet = True)
	if ret != 0:
	    grass.fatal(_("Error executing SQL query"))

	kv = grass.vector_info_topo(tmp_extr)
	if kv['primitives'] == 0:
	    grass.fatal(_("SQL query returned an empty map (no %s features?)") % type)

	inmap = tmp_extr
    else:
	#   g.copy "$GIS_OPT_INPUT,tmp_vogb_extr_$$"   # to get a copy of DB into local mapset
	#   INMAP="tmp_vogb_extr_$$"
	inmap = input

    #### set up projection info
    # TODO: check if we are already in ll/WGS84.  If so skip m.proj step.

    # TODO: multi layer will probably fail badly due to sed 's/^ 1   /'
    #   output as old GRASS 4 vector ascii and fight with dig_ascii/?
    #   Change to s/^ \([0-9]   .*\)    /# \1/' ??? mmph.

    # reproject to lat/lon WGS84
    grass.verbose("Reprojecting data ...")

    re1 = re.compile(r'^\([PLBCFKA]\)')
    re2 = re.compile(r'^ 1     ')

    re3 = re.compile(r'\t\([-\.0-9]*\) .*')
    re4 = re.compile(r'^\([-\.0-9]\)')
    re5 = re.compile(r'^#')

    tmp_proj = tmp + ".proj"
    tf = open(tmp_proj, 'w')
    p1 = grass.pipe_command('v.out.ascii', input = inmap, format = 'standard')
    p2 = grass.feed_command('m.proj', input = '-', flags = 'od', quiet = True, stdout = tf)
    tf.close()

    lineno = 0
    for line in p1.stdout:
	lineno += 1
	if lineno < 11:
	    continue
	line = re1.sub(r'#\1', line)
	line = re2.sub(r'# 1  ', line)
	p2.stdin.write(line)

    p2.stdin.close()
    p1.wait()
    p2.wait()

    if p1.returncode != 0 or p2.returncode != 0:
	grass.fatal(_("Error reprojecting data"))

    tmp_vogb = "tmp_vogb_epsg4326_%d" % os.getpid()
    p3 = grass.feed_command('v.in.ascii', out = tmp_vogb, format = 'standard', flags = 'n', quiet = True)
    tf = open(tmp_proj, 'r')

    for line in tf:
	line = re3.sub(r' \1', line)
	line = re4.sub(r' \1', line)
	line = re5.sub('', line)
	p3.stdin.write(line)

    p3.stdin.close()
    tf.close()
    p3.wait()

    if p3.returncode != 0:
	grass.fatal(_("Error reprojecting data"))

    # don't v.db.connect directly as source table will be removed with
    # temporary map in that case. So we make a temp copy of it to work with.
    kv = vector_db(inmap)
    if layer in kv:
	db_params = kv[layer]

	db_table = db_params['table']
	db_key = db_params['key']
	db_database = db_params['database']
	db_driver = db_params['driver']

	ret = grass.run_command('db.copy',
				from_driver = db_driver,
				from_database = db_database,
				from_table = db_table,
				to_table = tmp_vogb)
	if ret != 0:
	    grass.fatal(_("Error copying temporary DB"))

	ret = grass.run_command('v.db.connect', map = tmp_vogb, table = tmp_vogb, quiet = True)
	if ret != 0:
	    grass.fatal(_("Error reconnecting temporary DB"))

    # export as GPX using v.out.ogr
    if trk:
	linetype = "FORCE_GPX_TRACK=YES"
    elif rte:
	linetype = "FORCE_GPX_TRACK=YES"
    else:
	linetype = None

    # BUG: cat is being reported as evelation and attribute output is skipped.
    #   (v.out.ogr DB reading or ->OGR GPX driver bug<-
    #     resolved: see new Create opts at http://www.gdal.org/ogr/drv_gpx.html)
    #   v.out.ogr -> shapefile -> GPX works, but we try to avoid that as it's
    #     lossy. Also that would allow ogr2ogr -a_srs $IN_PROJ -t_srs EPSG:4326
    #     so skip m.proj pains.. if that is done ogr2ogr -s_srs MUST HAVE +wktext
    #     with PROJ.4 terms or else the +nadgrids will be ignored! best to feed
    #     it  IN_PROJ="`g.proj -jf` +wktext"  in that case.

    grass.verbose("Exporting data ...")

    tmp_gpx = tmp + ".gpx"
    ret = grass.run_command('v.out.ogr', input = tmp_vogb, dsn = tmp_gpx,
			    type = type, format = 'GPX', lco = linetype,
			    dsco = "GPX_USE_EXTENSIONS=YES", quiet = True)
    if ret != 0:
	grass.fatal(_("Error exporting data"))

    if format == 'gpx':
	# short circuit, we have what we came for.
	grass.try_remove(output)
	os.rename(tmp_gpx, output)
	grass.verbose("Fast exit.")
	sys.exit()

    # run gpsbabel
    if wpt:
	gtype = '-w'
    elif trk:
	gtype = '-t'
    elif rte:
	gtype = '-r'
    else:
	gtype = ''

    grass.verbose("Running GPSBabel ...")

    ret = grass.call(['gpsbabel',
		      gtype,
		      '-i', 'gpx',
		      '-f', tmp + '.gpx',
		      '-o', format,
		      '-F', output])

    if ret != 0:
	grass.fatal(_("Error running GPSBabel"))

    grass.verbose("Done.")
예제 #9
0
def main():
    global tile, tmpdir, in_temp

    in_temp = False

    input = options['input']
    output = options['output']
    one = flags['1']

    #are we in LatLong location?
    s = grass.read_command("g.proj", flags='j')
    kv = grass.parse_key_val(s)
    if kv['+proj'] != 'longlat':
	grass.fatal(_("This module only operates in LatLong locations"))

    # use these from now on:
    infile = input
    while infile[-4:].lower() in ['.hgt', '.zip']:
	infile = infile[:-4]
    (fdir, tile) = os.path.split(infile)

    if not output:
	tileout = tile
    else:
	tileout = output

    zipfile = infile + ".hgt.zip"
    hgtfile = os.path.join(fdir, tile[:7] + ".hgt")
    if os.path.isfile(zipfile):
        #### check if we have unzip
	if not grass.find_program('unzip'):
	    grass.fatal(_('The "unzip" program is required, please install it first'))

	# really a ZIP file?
	# make it quiet in a safe way (just in case -qq isn't portable)
	tenv = os.environ.copy()
	tenv['UNZIP'] = '-qq'
	if grass.call(['unzip', '-t', zipfile], env = tenv) != 0:
	    grass.fatal(_("'%s' does not appear to be a valid zip file.") % zipfile)

	is_zip = True
    elif os.path.isfile(hgtfile):
	# try and see if it's already unzipped
	is_zip = False
    else:
	grass.fatal(_("File '%s' or '%s' not found") % (zipfile, hgtfile))

    #make a temporary directory
    tmpdir = grass.tempfile()
    grass.try_remove(tmpdir)
    os.mkdir(tmpdir)

    if is_zip:
	shutil.copyfile(zipfile, os.path.join(tmpdir, tile + ".hgt.zip"))
    else:
	shutil.copyfile(hgtfile, os.path.join(tmpdir, tile + ".hgt"))

    #change to temporary directory
    os.chdir(tmpdir)
    in_temp = True

    zipfile = tile + ".hgt.zip"
    hgtfile = tile[:7] + ".hgt"
    bilfile = tile + ".bil"

    if is_zip:
        #unzip & rename data file:
	grass.message(_("Extracting '%s'...") % infile)
	if grass.call(['unzip', zipfile], env = tenv) != 0:
	    grass.fatal(_("Unable to unzip file."))

    grass.message(_("Converting input file to BIL..."))
    os.rename(hgtfile, bilfile)

    north = tile[0]
    ll_latitude  = int(tile[1:3])
    east = tile[3]
    ll_longitude = int(tile[4:7])

    # are we on the southern hemisphere? If yes, make LATITUDE negative.
    if north == "S":
	ll_latitude *= -1

    # are we west of Greenwich? If yes, make LONGITUDE negative.
    if east == "W":
	ll_longitude *= -1

    # Calculate Upper Left from Lower Left
    ulxmap = "%.1f" % ll_longitude
    # SRTM90 tile size is 1 deg:
    ulymap = "%.1f" % (ll_latitude + 1)

    if not one:
	tmpl = tmpl3sec
    else:
	grass.message(_("Attempting to import 1-arcsec data."))
	tmpl = tmpl1sec

    header = tmpl % (ulxmap, ulymap)
    hdrfile = tile + '.hdr'
    outf = file(hdrfile, 'w')
    outf.write(header)
    outf.close()

    #create prj file: To be precise, we would need EGS96! But who really cares...
    prjfile = tile + '.prj'
    outf = file(prjfile, 'w')
    outf.write(proj)
    outf.close()

    try:
        grass.run_command('r.in.gdal', input=bilfile, out=tileout)
    except:
        grass.fatal(_("Unable to import data"))

    # nice color table
    grass.run_command('r.colors', map = tileout, color = 'srtm')

    # write cmd history:
    grass.raster_history(tileout)

    grass.message(_("Done: generated map ") + tileout)
    grass.message(_("(Note: Holes in the data can be closed with 'r.fillnulls' using splines)"))
예제 #10
0
def main():
    # parameters
    infile = options['input']
    raster_reference = options['raster_reference']
    raster_file = options['raster_file']
    outfile = options['output']
    resolution = options['resolution']
    method = options['method']
    zrange = options['zrange']
    zscale = options['zscale']
    output_type = options['type']
    percent = options['percent']
    pth = options['pth']
    trim = options['trim']
    footprint = options['footprint']
    # flags
    scan = flags['s']
    shell_script_style = flags['g']

    # overwrite auf true setzen
    os.environ['GRASS_OVERWRITE'] = '1'

    # to hide non-error messages from subprocesses
    if grass.verbosity() <= 2:
        outdev = open(os.devnull, 'w')
    else:
        outdev = sys.stdout

    # use temporary region
    grass.use_temp_region()

    # scan -s or shell_script_style -g:
    if scan:
        if not grass.find_program(
                options['pdal_cmd'].split(' ')[0],
                ' '.join(options['pdal_cmd'].split(' ')[1:]) +
                ' info --summary'):
            grass.fatal(
                _("The pdal program is not in the path " +
                  "and executable. Please install first"))
        command_scan = options['pdal_cmd'].split(' ')
        command_scan.extend(['info', '--summary', infile])

        tmp_scan = grass.tempfile()
        if tmp_scan is None:
            grass.fatal("Unable to create temporary files")
        fh = open(tmp_scan, 'wb')
        summary = True
        if grass.call(command_scan, stdout=fh) != 0:
            fh.close()
            command_scan = options['pdal_cmd'].split(' ')
            command_scan.extend(['info', infile])
            fh2 = open(tmp_scan, 'wb')
            if grass.call(command_scan, stdout=fh2) != 0:
                os.remove(tmp_scan)
                grass.fatal(
                    _("pdal cannot determine metadata " +
                      "for unsupported format of <%s>") % infile)
                fh2.close()
            else:
                fh2.close()
            summary = False
        else:
            fh.close()

        data = json.load(open(tmp_scan))
        if summary:
            str1 = u'summary'
            str2 = u'bounds'
            y_str = u'Y'
            x_str = u'X'
            z_str = u'Z'
            min_str = u'min'
            max_str = u'max'
            try:
                n = str(data[str1][str2][y_str][max_str])
                s = str(data[str1][str2][y_str][min_str])
                w = str(data[str1][str2][x_str][min_str])
                e = str(data[str1][str2][x_str][max_str])
                t = str(data[str1][str2][z_str][max_str])
                b = str(data[str1][str2][z_str][min_str])
            except:
                ymin_str = u'miny'
                xmin_str = u'minx'
                zmin_str = u'minz'
                ymax_str = u'maxy'
                xmax_str = u'maxx'
                zmax_str = u'maxz'
                n = str(data[str1][str2][ymax_str])
                s = str(data[str1][str2][ymin_str])
                w = str(data[str1][str2][xmin_str])
                e = str(data[str1][str2][xmax_str])
                t = str(data[str1][str2][zmax_str])
                b = str(data[str1][str2][zmin_str])
        else:
            str1 = u'stats'
            str2 = u'bbox'
            str3 = u'native'
            str4 = u'bbox'
            n = str(data[str1][str2][str3][str4][u'maxy'])
            s = str(data[str1][str2][str3][str4][u'miny'])
            w = str(data[str1][str2][str3][str4][u'minx'])
            e = str(data[str1][str2][str3][str4][u'maxx'])
            t = str(data[str1][str2][str3][str4][u'maxz'])
            b = str(data[str1][str2][str3][str4][u'minz'])
        if not shell_script_style:
            grass.message(
                _("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
                  ) % (n, s, w, e, t, b))
        else:
            grass.message(
                _("n=%s s=%s w=%s e=%s t=%s b=%s") % (n, s, w, e, t, b))
    elif footprint:
        footprint_to_vectormap(infile, footprint)
    else:
        # get region with pdal
        footprint_to_vectormap(infile, 'tiles')

        if raster_file:
            raster_reference = 'img' + str(os.getpid())
            grass.run_command('r.external',
                              input=raster_file,
                              flags='o',
                              output=raster_reference)
            result = grass.find_file(name=raster_reference, element='raster')
            if result[u'fullname'] == u'':
                raster_reference = raster_reference + '.1'
        # option 1: set region to extent of tiles while precisely aligning pixel
        # geometry to raster_reference (including both raster_reference and raster_file)
        if raster_reference:
            grass.run_command('g.region',
                              vector='tiles',
                              flags='g',
                              align=raster_reference)
        else:
            # option 2: change raster resolution to final resolution while best
            # effort aligning to pixel geometry
            grass.run_command('g.region',
                              vector='tiles',
                              flags='ap',
                              res=resolution)
        # generate PDAL pipeline
        # . pdal pipline laz2json (STDOUT) | r.in.xyz
        bn = os.path.basename(infile)
        infile_format = bn.split('.')[-1]
        # format_reader from https://pdal.io/stages/readers.html
        format_reader = ''
        if infile_format.lower() == 'laz' or infile_format.lower() == 'las':
            format_reader = 'readers.las'
        # pts: not tested
        elif infile_format.lower() == 'pts':
            format_reader = 'readers.pts'
        else:
            grass.run_command('g.remove',
                              flags='f',
                              type='vector',
                              name='tiles',
                              quiet=True)
            grass.fatal(_("Format .%s is not supported.." % infile_format))
        tmp_file_json = 'tmp_file_json_' + str(os.getpid())

        data = {}
        data['pipeline'] = []
        data['pipeline'].append({'type': format_reader, 'filename': infile})
        data['pipeline'].append({
            'type': 'writers.text',
            'format': 'csv',
            'order': 'X,Y,Z',
            'keep_unspecified': 'false',
            'filename': 'STDOUT',
            'quote_header': 'false'
        })
        with open(tmp_file_json, 'w') as f:
            json.dump(data, f)

        tmp_xyz = grass.tempfile()
        if tmp_xyz is None:
            grass.fatal("Unable to create temporary files")
        command_pdal1 = options['pdal_cmd'].split(' ')
        if options['pdal_cmd'] != 'pdal':
            v_index = None
            cmd_entries = options['pdal_cmd'].split(' ')
            for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
                if cmd_entry == '-v':
                    v_index = num
                    break
            mnt_vol = cmd_entries[v_index + 1].split(':')[1]
            tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
        else:
            tmp_file_json2 = tmp_file_json
        command_pdal1.extend(['pipeline', '--input', tmp_file_json2])
        command_pdal2 = [
            'r.in.xyz', 'input=' + tmp_xyz, 'output=' + outfile, 'skip=1',
            'separator=comma', 'method=' + method
        ]

        if zrange:
            command_pdal2.append('zrange=' + zrange)
        if zscale:
            command_pdal2.append('zscale=' + zscale)
        if output_type:
            command_pdal2.append('type=' + output_type)
        if percent:
            command_pdal2.append('percent=' + percent)
        if pth:
            command_pdal2.append('pth=' + pth)
        if trim:
            command_pdal2.append('trim=' + trim)

        fh = open(tmp_xyz, 'wb')
        if grass.call(command_pdal1, stdout=fh) != 0:
            fh.close()
            # check to see if pdal pipeline executed properly
            grass.fatal(_("pdal pipeline is broken..."))
        else:
            fh.close()

        if grass.call(command_pdal2, stdout=outdev) != 0:
            # check to see if r.in.xyz executed properly
            os.remove(tmp_xyz)
            grass.fatal(_("r.in.xyz is broken..."))

        # metadata
        empty_history = grass.tempfile()
        if empty_history is None:
            grass.fatal("Unable to create temporary files")
        f = open(empty_history, 'w')
        f.close()
        grass.run_command('r.support',
                          map=outfile,
                          source1=infile,
                          description='generated by r.in.pdal',
                          loadhistory=empty_history)
        grass.run_command('r.support',
                          map=outfile,
                          history=os.environ['CMDLINE'])
        os.remove(empty_history)

        # Cleanup
        grass.message(_("Cleaning up..."))
        grass.run_command('g.remove',
                          flags='f',
                          type='vector',
                          name='tiles',
                          quiet=True)
        if raster_file:
            grass.run_command('g.remove',
                              flags='f',
                              type='raster',
                              pattern=raster_reference[:-1] + '*',
                              quiet=True)
        os.remove(tmp_file_json)
        os.remove(tmp_xyz)
        grass.message(_("Generating output raster map <%s>...") % outfile)
        grass.del_temp_region()
예제 #11
0
def footprint_to_vectormap(infile, footprint):
    """ The function generates a footprint as vectormap of the input las-file.
    It uses pdal info --boundary.

    Args:
        infile(string): Name of LAS input file
        footprint(string): Footprint of the data as vector map
    """
    if not grass.find_program(
            options['pdal_cmd'].split(' ')[0],
            ' '.join(options['pdal_cmd'].split(' ')[1:]) + ' info --boundary'):
        grass.fatal(
            _("The pdal executable is not available."
              " Install PDAL or put the pdal executable on path."))
    command_fp = options['pdal_cmd'].split(' ')
    command_fp.extend(['info', '--boundary', infile])
    tmp_fp = grass.tempfile()
    if tmp_fp is None:
        grass.fatal("Unable to create temporary files")
    fh = open(tmp_fp, 'wb')
    if grass.call(command_fp, stdout=fh) != 0:
        fh.close()
        # check to see if pdal info executed properly
        os.remove(tmp_fp)
        grass.fatal(_("pdal info broken..."))
    else:
        fh.close()
    data = json.load(open(tmp_fp))
    xy_in = ''
    str1 = u'boundary'
    try:
        str2 = u'boundary_json'
        str3 = u'coordinates'
        coord = data[str1][str2][str3][0][0]
        for xy in coord:
            xy_in += str(xy[0]) + ',' + str(xy[1]) + '\n'
    except Exception:
        coord_str = str(data[str1][str1])
        coord = coord_str[coord_str.find('((') + 2:coord_str.find('))')]
        x_y = coord.split(',')
        for xy in x_y:
            xy_in += xy.rstrip().replace(' ', ',') + '\n'
    tmp_xy = grass.tempfile()
    if tmp_xy is None:
        grass.fatal("Unable to create temporary files")
    f = open(tmp_xy, 'w')
    f.write(xy_in[:-1])
    f.close()
    grass.run_command('v.in.lines',
                      input=tmp_xy,
                      output='footprint_line',
                      separator='comma')
    grass.run_command('g.region', vector='footprint_line')
    grass.run_command('v.type',
                      input='footprint_line',
                      out='footprint_boundary',
                      from_type='line',
                      to_type='boundary')
    grass.run_command('v.centroids', input='footprint_boundary', out=footprint)
    grass.run_command('v.db.addtable',
                      map=footprint,
                      columns='name varchar(50)')
    grass.run_command('v.db.update',
                      map=footprint,
                      column='name',
                      value=infile)

    # Cleaning up
    grass.message(_("Cleaning up..."))
    os.remove(tmp_fp)
    os.remove(tmp_xy)
    grass.run_command('g.remove',
                      flags='f',
                      type='vector',
                      name='footprint_line',
                      quiet=True)
    grass.run_command('g.remove',
                      flags='f',
                      type='vector',
                      name='footprint_boundary',
                      quiet=True)

    # metadata
    grass.run_command('v.support',
                      map=footprint,
                      comment='in ' + os.environ['CMDLINE'])

    grass.message(_("Generating output vector map <%s>...") % footprint)
예제 #12
0
def main():
    # parameters
    infile = options['input']
    raster_reference = options['raster_reference']
    raster_file = options['raster_file']
    outfiles = options['output']
    resolution = options['resolution']
    methods = options['method']
    zrange = options['zrange']
    zscale = options['zscale']
    output_type = options['type']
    percent = options['percent']
    pth = options['pth']
    trim = options['trim']
    footprint = options['footprint']
    # flags
    scan = flags['s']
    shell_script_style = flags['g']

    if len(outfiles.split(",")) != len(methods.split(",")):
        grass.fatal(
            _("Number of outputs <%s> does not match number of methods <%s>" %
              (outfiles, methods)))

    # overwrite auf true setzen
    os.environ['GRASS_OVERWRITE'] = '1'

    # to hide non-error messages from subprocesses
    if grass.verbosity() <= 2:
        outdev = open(os.devnull, 'w')
    else:
        outdev = sys.stdout

    # use temporary region
    grass.use_temp_region()

    n, s, w, e, t, b = scan_extent(infile)

    # scan -s or shell_script_style -g:
    if scan:
        if not shell_script_style:
            grass.message(
                _("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
                  ) % (n, s, w, e, t, b))
        else:
            # shell script style: print to stdout
            print("n=%s s=%s w=%s e=%s t=%s b=%s" % (n, s, w, e, t, b))
    elif footprint:
        footprint_to_vectormap(infile, footprint)
    else:
        # get region with pdal
        #footprint_to_vectormap(infile, 'tiles')

        if raster_file:
            raster_reference = 'img' + str(os.getpid())
            grass.run_command('r.external',
                              input=raster_file,
                              flags='o',
                              output=raster_reference)
            result = grass.find_file(name=raster_reference, element='raster')
            if result[u'fullname'] == u'':
                raster_reference = raster_reference + '.1'
        # option 1: set region to extent of tiles while precisely aligning pixel
        # geometry to raster_reference (including both raster_reference and raster_file)
        if raster_reference:
            grass.run_command('g.region',
                              n=n,
                              s=s,
                              e=e,
                              w=w,
                              flags='g',
                              align=raster_reference)
        else:
            # option 2: change raster resolution to final resolution while best
            # effort aligning to pixel geometry
            grass.run_command('g.region',
                              n=n,
                              s=s,
                              e=e,
                              w=w,
                              flags='ap',
                              res=resolution)
        # generate PDAL pipeline
        # . pdal pipline laz2json (STDOUT) | r.in.xyz
        bn = os.path.basename(infile)
        infile_format = bn.split('.')[-1]
        # format_reader from https://pdal.io/stages/readers.html
        format_reader = ''
        if infile_format.lower() == 'laz' or infile_format.lower() == 'las':
            format_reader = 'readers.las'
        # pts: not tested
        elif infile_format.lower() == 'pts':
            format_reader = 'readers.pts'
        else:
            grass.run_command('g.remove',
                              flags='f',
                              type='vector',
                              name='tiles',
                              quiet=True)
            grass.fatal(_("Format .%s is not supported.." % infile_format))

        grass.message(_("Converting input file <%s>...") % infile)
        tmp_file_json = 'tmp_file_json_' + str(os.getpid())

        data = {}
        data['pipeline'] = []
        data['pipeline'].append({'type': format_reader, 'filename': infile})
        data['pipeline'].append({
            'type': 'writers.text',
            'format': 'csv',
            'order': 'X,Y,Z',
            'keep_unspecified': 'false',
            'filename': 'STDOUT',
            'quote_header': 'false'
        })
        with open(tmp_file_json, 'w') as f:
            json.dump(data, f)

        tmp_xyz = grass.tempfile()
        if tmp_xyz is None:
            grass.fatal("Unable to create temporary files")
        command_pdal1 = options['pdal_cmd'].split(' ')
        if options['pdal_cmd'] != 'pdal':
            v_index = None
            cmd_entries = options['pdal_cmd'].split(' ')
            for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
                if cmd_entry == '-v':
                    v_index = num
                    break
            mnt_vol = cmd_entries[v_index + 1].split(':')[1]
            tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
        else:
            tmp_file_json2 = tmp_file_json
        command_pdal1.extend(['pipeline', '--input', tmp_file_json2])

        fh = open(tmp_xyz, 'wb')
        if grass.call(command_pdal1, stdout=fh) != 0:
            fh.close()
            # check to see if pdal pipeline executed properly
            print(command_pdal1)
            grass.fatal(_("pdal pipeline is broken..."))
        else:
            fh.close()

        for i in range(len(methods.split(","))):
            method = methods.split(",")[i]
            outfile = outfiles.split(",")[i]

            grass.message(_("Generating output raster map <%s>...") % outfile)

            command_pdal2 = [
                'r.in.xyz', 'input=' + tmp_xyz, 'output=' + outfile, 'skip=1',
                'separator=comma', 'method=' + method
            ]

            if zrange:
                command_pdal2.append('zrange=' + zrange)
            if zscale:
                command_pdal2.append('zscale=' + zscale)
            if output_type:
                command_pdal2.append('type=' + output_type)
            if percent:
                command_pdal2.append('percent=' + percent)
            if pth:
                command_pdal2.append('pth=' + pth)
            if trim:
                command_pdal2.append('trim=' + trim)

            if grass.call(command_pdal2, stdout=outdev) != 0:
                # check to see if r.in.xyz executed properly
                os.remove(tmp_xyz)
                grass.fatal(_("r.in.xyz is broken..."))

            # metadata
            empty_history = grass.tempfile()
            if empty_history is None:
                grass.fatal("Unable to create temporary files")
            f = open(empty_history, 'w')
            f.close()
            grass.run_command('r.support',
                              map=outfile,
                              source1=infile,
                              description='generated by r.in.pdal',
                              loadhistory=empty_history)
            grass.run_command('r.support',
                              map=outfile,
                              history=os.environ['CMDLINE'])
            os.remove(empty_history)

        # Cleanup
        grass.message(_("Cleaning up..."))
        grass.run_command('g.remove',
                          flags='f',
                          type='vector',
                          name='tiles',
                          quiet=True)
        if raster_file:
            grass.run_command('g.remove',
                              flags='f',
                              type='raster',
                              pattern=raster_reference[:-1] + '*',
                              quiet=True)
        os.remove(tmp_file_json)
        os.remove(tmp_xyz)
        grass.del_temp_region()
예제 #13
0
def scan_extent(infile):
    if not grass.find_program(
            options['pdal_cmd'].split(' ')[0],
            ' '.join(options['pdal_cmd'].split(' ')[1:]) + ' info --summary'):
        grass.fatal(
            _("The pdal program is not in the path " +
              "and executable. Please install first"))
    command_scan = options['pdal_cmd'].split(' ')
    command_scan.extend(['info', '--summary', infile])

    tmp_scan = grass.tempfile()
    if tmp_scan is None:
        grass.fatal("Unable to create temporary files")
    fh = open(tmp_scan, 'wb')
    summary = True
    if grass.call(command_scan, stdout=fh) != 0:
        fh.close()
        command_scan = options['pdal_cmd'].split(' ')
        command_scan.extend(['info', infile])
        fh2 = open(tmp_scan, 'wb')
        if grass.call(command_scan, stdout=fh2) != 0:
            os.remove(tmp_scan)
            grass.fatal(
                _("pdal cannot determine metadata " +
                  "for unsupported format of <%s>") % infile)
            fh2.close()
        else:
            fh2.close()
        summary = False
    else:
        fh.close()

    data = json.load(open(tmp_scan))
    if summary:
        str1 = u'summary'
        str2 = u'bounds'
        y_str = u'Y'
        x_str = u'X'
        z_str = u'Z'
        min_str = u'min'
        max_str = u'max'
        try:
            n = str(data[str1][str2][y_str][max_str])
            s = str(data[str1][str2][y_str][min_str])
            w = str(data[str1][str2][x_str][min_str])
            e = str(data[str1][str2][x_str][max_str])
            t = str(data[str1][str2][z_str][max_str])
            b = str(data[str1][str2][z_str][min_str])
        except:
            ymin_str = u'miny'
            xmin_str = u'minx'
            zmin_str = u'minz'
            ymax_str = u'maxy'
            xmax_str = u'maxx'
            zmax_str = u'maxz'
            n = str(data[str1][str2][ymax_str])
            s = str(data[str1][str2][ymin_str])
            w = str(data[str1][str2][xmin_str])
            e = str(data[str1][str2][xmax_str])
            t = str(data[str1][str2][zmax_str])
            b = str(data[str1][str2][zmin_str])
    else:
        str1 = u'stats'
        str2 = u'bbox'
        str3 = u'native'
        str4 = u'bbox'
        n = str(data[str1][str2][str3][str4][u'maxy'])
        s = str(data[str1][str2][str3][str4][u'miny'])
        w = str(data[str1][str2][str3][str4][u'minx'])
        e = str(data[str1][str2][str3][str4][u'maxx'])
        t = str(data[str1][str2][str3][str4][u'maxz'])
        b = str(data[str1][str2][str3][str4][u'minz'])

    return n, s, w, e, t, b
예제 #14
0
def main():
    global tmp_rmaps

    # user keys
    in_raster = options["input"]  # in_raster = 'srtm_1sec_amazonia'
    out_raster = options["output"]  # out_raster = 'teste_dnoise'
    iterations = options["iterations"]
    threshold = options["threshold"]
    epsg = options["epsg"]

    # check if input file exists
    if not grass.find_file(in_raster)["file"]:
        grass.fatal(_("Raster map <%s> not found") % in_raster)

    # name the files
    tmp_xyz = "{}.xyz".format(grass.tempfile())
    tmp_xyz_proj = "{}.xyz".format(grass.tempfile())
    tmp_out_dnoise = "{}.xyz".format(grass.tempfile())
    tmp_xyz_merge = "{}.xyz".format(grass.tempfile())
    # list for cleanup
    tmp_rmaps = [tmp_xyz, tmp_xyz_proj, tmp_out_dnoise, tmp_xyz_merge]

    # Export the map to xyz points.
    grass.message(_("Exporting points..."))
    grass.run_command("r.out.xyz",
                      input=in_raster,
                      output=tmp_xyz,
                      separator="space",
                      overwrite=True)

    # check if current location is in a projected coordinate system
    reproject = check_proj(epsg)

    # Reproject if necessary
    if reproject:
        # define projections
        loc_proj = grass.read_command("g.proj", flags="jf")
        loc_proj = pyproj.Proj(loc_proj.strip())
        epsg_proj = pyproj.Proj(init="epsg:" + str(epsg))
        do_proj(xyz_in=tmp_xyz,
                xyz_out=tmp_xyz_proj,
                in_proj=loc_proj,
                out_proj=epsg_proj)
        tmp_xyz = tmp_xyz_proj

    # Denoise.  The -z flag preserves the xy positions of the points.
    grass.message(_("Denoising..."))
    cmd = (["mdenoise"] + ["-i"] + [tmp_xyz] + ["-t"] + [str(threshold)] +
           ["-n"] + [str(iterations)] + ["-z"] + ["-o"] + [tmp_out_dnoise])
    grass.call(cmd)

    # As only the z coordinates have changed in denoising,
    # the new z coordinates are combined with the original xy coordinates.
    f_merged = open(tmp_xyz_merge, "w")  # new, merged
    # read input coordinates file

    with open(tmp_out_dnoise) as f_dnoise, open(tmp_xyz) as f_orig:
        for line_dnoise, line_orig in zip(f_dnoise, f_orig):
            xyz_dnoise = line_dnoise.split()  # denoised
            xyz_orig = line_orig.split()  # original
            f_merged.write("%s %s %s\n" %
                           (xyz_orig[0], xyz_orig[1], xyz_dnoise[2]))

    # close files
    f_merged.close()

    # Reload data
    grass.message(_("Reloading data..."))
    grass.run_command(
        "r.in.xyz",
        flags="i",
        input=tmp_xyz_merge,
        output=out_raster,
        method="min",
        x=1,
        y=2,
        z=3,
        separator="space",
        overwrite=True,
    )

    # Edit metadata to record denoising parameters
    grass.run_command("r.support",
                      map=out_raster,
                      title="A denoised version of <%s>" % in_raster)
    grass.run_command(
        "r.support",
        map=out_raster,
        history="Generated by: r.denoise %s iterations=%s threshold=%s" %
        (in_raster, str(threshold), str(iterations)),
    )
예제 #15
0
def main():
    global tile, tmpdir, in_temp

    in_temp = False

    input = options['input']
    output = options['output']
    one = flags['1']

    # are we in LatLong location?
    s = grass.read_command("g.proj", flags='j')
    kv = grass.parse_key_val(s)
    if kv['+proj'] != 'longlat':
        grass.fatal(_("This module only operates in LatLong locations"))

    # use these from now on:
    infile = input
    while infile[-4:].lower() in ['.hgt', '.zip']:
        infile = infile[:-4]
    (fdir, tile) = os.path.split(infile)

    if not output:
        tileout = tile
    else:
        tileout = output

    zipfile = infile + ".hgt.zip"
    hgtfile = os.path.join(fdir, tile[:7] + ".hgt")
    if os.path.isfile(zipfile):
        # check if we have unzip
        if not grass.find_program('unzip'):
            grass.fatal(
                _('The "unzip" program is required, please install it first'))

        # really a ZIP file?
        # make it quiet in a safe way (just in case -qq isn't portable)
        tenv = os.environ.copy()
        tenv['UNZIP'] = '-qq'
        if grass.call(['unzip', '-t', zipfile], env=tenv) != 0:
            grass.fatal(
                _("'%s' does not appear to be a valid zip file.") % zipfile)

        is_zip = True
    elif os.path.isfile(hgtfile):
        # try and see if it's already unzipped
        is_zip = False
    else:
        grass.fatal(_("File '%s' or '%s' not found") % (zipfile, hgtfile))

    # make a temporary directory
    tmpdir = grass.tempfile()
    grass.try_remove(tmpdir)
    os.mkdir(tmpdir)

    if is_zip:
        shutil.copyfile(zipfile, os.path.join(tmpdir, tile + ".hgt.zip"))
    else:
        shutil.copyfile(hgtfile, os.path.join(tmpdir, tile + ".hgt"))

    # change to temporary directory
    os.chdir(tmpdir)
    in_temp = True

    zipfile = tile + ".hgt.zip"
    hgtfile = tile[:7] + ".hgt"
    bilfile = tile + ".bil"

    if is_zip:
        # unzip & rename data file:
        grass.message(_("Extracting '%s'...") % infile)
        if grass.call(['unzip', zipfile], env=tenv) != 0:
            grass.fatal(_("Unable to unzip file."))

    grass.message(_("Converting input file to BIL..."))
    os.rename(hgtfile, bilfile)

    north = tile[0]
    ll_latitude = int(tile[1:3])
    east = tile[3]
    ll_longitude = int(tile[4:7])

    # are we on the southern hemisphere? If yes, make LATITUDE negative.
    if north == "S":
        ll_latitude *= -1

    # are we west of Greenwich? If yes, make LONGITUDE negative.
    if east == "W":
        ll_longitude *= -1

    # Calculate Upper Left from Lower Left
    ulxmap = "%.1f" % ll_longitude
    # SRTM90 tile size is 1 deg:
    ulymap = "%.1f" % (ll_latitude + 1)

    if not one:
        tmpl = tmpl3sec
    else:
        grass.message(_("Attempting to import 1-arcsec data."))
        tmpl = tmpl1sec

    header = tmpl % (ulxmap, ulymap)
    hdrfile = tile + '.hdr'
    outf = file(hdrfile, 'w')
    outf.write(header)
    outf.close()

    # create prj file: To be precise, we would need EGS96! But who really cares...
    prjfile = tile + '.prj'
    outf = file(prjfile, 'w')
    outf.write(proj)
    outf.close()

    try:
        grass.run_command('r.in.gdal', input=bilfile, out=tileout)
    except:
        grass.fatal(_("Unable to import data"))

    # nice color table
    grass.run_command('r.colors', map=tileout, color='srtm')

    # write cmd history:
    grass.raster_history(tileout)

    grass.message(_("Done: generated map ") + tileout)
    grass.message(
        _("(Note: Holes in the data can be closed with 'r.fillnulls' using splines)"
          ))
예제 #16
0
def footprint_to_vectormap(infile, footprint):
    """The function generates a footprint as vectormap of the input las-file.
    It uses pdal info --boundary.

    Args:
        infile(string): Name of LAS input file
        footprint(string): Footprint of the data as vector map
    """
    if not grass.find_program(
            options["pdal_cmd"].split(" ")[0],
            " ".join(options["pdal_cmd"].split(" ")[1:]) + " info --boundary",
    ):
        grass.fatal(
            _("The pdal executable is not available."
              " Install PDAL or put the pdal executable on path."))
    command_fp = options["pdal_cmd"].split(" ")
    command_fp.extend(["info", "--boundary", infile])
    tmp_fp = grass.tempfile()
    if tmp_fp is None:
        grass.fatal("Unable to create temporary files")
    fh = open(tmp_fp, "wb")
    if grass.call(command_fp, stdout=fh) != 0:
        fh.close()
        # check to see if pdal info executed properly
        os.remove(tmp_fp)
        grass.fatal(_("pdal info broken..."))
    else:
        fh.close()
    data = json.load(open(tmp_fp))
    xy_in = ""
    str1 = u"boundary"
    try:
        str2 = u"boundary_json"
        str3 = u"coordinates"
        coord = data[str1][str2][str3][0][0]
        for xy in coord:
            xy_in += str(xy[0]) + "," + str(xy[1]) + "\n"
    except Exception:
        coord_str = str(data[str1][str1])
        coord = coord_str[coord_str.find("((") + 2:coord_str.find("))")]
        x_y = coord.split(",")
        for xy in x_y:
            xy_in += xy.rstrip().replace(" ", ",") + "\n"
    tmp_xy = grass.tempfile()
    if tmp_xy is None:
        grass.fatal("Unable to create temporary files")
    f = open(tmp_xy, "w")
    f.write(xy_in[:-1])
    f.close()
    grass.run_command("v.in.lines",
                      input=tmp_xy,
                      output="footprint_line",
                      separator="comma")
    grass.run_command("g.region", vector="footprint_line")
    grass.run_command(
        "v.type",
        input="footprint_line",
        out="footprint_boundary",
        from_type="line",
        to_type="boundary",
    )
    grass.run_command("v.centroids", input="footprint_boundary", out=footprint)
    grass.run_command("v.db.addtable",
                      map=footprint,
                      columns="name varchar(50)")
    grass.run_command("v.db.update",
                      map=footprint,
                      column="name",
                      value=infile)

    # Cleaning up
    grass.message(_("Cleaning up..."))
    os.remove(tmp_fp)
    os.remove(tmp_xy)
    grass.run_command("g.remove",
                      flags="f",
                      type="vector",
                      name="footprint_line",
                      quiet=True)
    grass.run_command("g.remove",
                      flags="f",
                      type="vector",
                      name="footprint_boundary",
                      quiet=True)

    # metadata
    grass.run_command("v.support",
                      map=footprint,
                      comment="in " + os.environ["CMDLINE"])

    grass.message(_("Generating output vector map <%s>...") % footprint)
예제 #17
0
def main():
    format = options["format"]
    input = options["input"]
    output = options["output"]
    proj_terms = options["proj"]
    wpt = flags["w"]
    rte = flags["r"]
    trk = flags["t"]
    points_mode = flags["p"]
    no_reproj = flags["k"]

    nflags = len(filter(None, [wpt, rte, trk]))
    if nflags > 1:
        grass.fatal(_("One feature at a time please."))
    if nflags < 1:
        grass.fatal(_("No features requested for import."))

    #### check for gpsbabel
    ### FIXME: may need --help or similar?
    if not grass.find_program("gpsbabel"):
        grass.fatal(
            _("The gpsbabel program was not found, please install it first.\n")
            + "http://gpsbabel.sourceforge.net"
        )

    #### check for cs2cs
    if not grass.find_program("cs2cs"):
        grass.fatal(
            _("The cs2cs program was not found, please install it first.\n")
            + "http://proj.osgeo.org"
        )

    # todo
    #    # check if we will overwrite data
    #    if grass.findfile(output) and not grass.overwrite():
    #        grass.fatal(_("Output file already exists."))

    #### set temporary files
    tmp = grass.tempfile()

    # import as GPX using v.in.ogr
    #     if trk:
    #         linetype = "FORCE_GPX_TRACK=YES"
    #     elif rte:
    #         linetype = "FORCE_GPX_TRACK=YES"
    #     else:
    #         linetype = None

    if format == "gpx":
        # short circuit, we have what we came for.
        # todo
        #        grass.try_remove(output)
        #        os.rename(tmp_gpx, output)
        grass.verbose("Fast exit.")
        sys.exit()

    # run gpsbabel
    if wpt:
        gtype = "-w"
    elif trk:
        gtype = "-t"
    elif rte:
        gtype = "-r"
    else:
        gtype = ""

    grass.verbose("Running GPSBabel ...")

    ret = grass.call(
        ["gpsbabel", gtype, "-i", format, "-f", output, "-o", "gpx", "-F", tmp + ".gpx"]
    )

    if ret != 0:
        grass.fatal(_("Error running GPSBabel"))

    grass.verbose("Importing data ...")

    tmp_gpx = tmp + ".gpx"
    try:
        grass.run_command(
            "v.in.ogr",
            input=tmp_gpx,
            output=output,
            type=type,
            format="GPX",
            lco=linetype,
            dsco="GPX_USE_EXTENSIONS=YES",
            quiet=True,
        )
    except CalledModuleError:
        grass.fatal(_("Error importing data"))

    #### set up projection info
    # TODO: check if we are already in ll/WGS84.  If so skip m.proj step.

    # TODO: multi layer will probably fail badly due to sed 's/^ 1   /'
    #   output as old GRASS 4 vector ascii and fight with dig_ascii/?
    #   Change to s/^ \([0-9]   .*\)    /# \1/' ??? mmph.

    # todo (taken from Glynn's v.out.gps)
    # reproject to lat/lon WGS84
    #     grass.verbose("Reprojecting data ...")
    #
    #     re1 = re.compile(r'^\([PLBCFKA]\)')
    #     re2 = re.compile(r'^ 1     ')
    #
    #     re3 = re.compile(r'\t\([-\.0-9]*\) .*')
    #     re4 = re.compile(r'^\([-\.0-9]\)')
    #     re5 = re.compile(r'^#')
    #
    #     tmp_proj = tmp + ".proj"
    #     tf = open(tmp_proj, 'w')
    #     p1 = grass.pipe_command('v.out.ascii', input = inmap, format = 'standard')
    #     p2 = grass.feed_command('m.proj', input = '-', flags = 'od', quiet = True, stdout = tf)
    #     tf.close()
    #
    #     lineno = 0
    #     for line in p1.stdout:
    #         lineno += 1
    #         if lineno < 11:
    #             continue
    #         line = re1.sub(r'#\1', line)
    #         line = re2.sub(r'# 1  ', line)
    #         p2.stdin.write(line)
    #
    #     p2.stdin.close()
    #     p1.wait()
    #     p2.wait()
    #
    #     if p1.returncode != 0 or p2.returncode != 0:
    #         grass.fatal(_("Error reprojecting data"))
    #
    #     tmp_vogb = "tmp_vogb_epsg4326_%d" % os.getpid()
    #     p3 = grass.feed_command('v.in.ascii', out = tmp_vogb, format = 'standard', flags = 'n', quiet = True)
    #     tf = open(tmp_proj, 'r')
    #
    #     for line in tf:
    #         line = re3.sub(r' \1', line)
    #         line = re4.sub(r' \1', line)
    #         line = re5.sub('', line)
    #         p3.stdin.write(line)
    #
    #     p3.stdin.close()
    #     tf.close()
    #     p3.wait()
    #
    #     if p3.returncode != 0:
    #         grass.fatal(_("Error reprojecting data"))

    grass.verbose("Done.")
예제 #18
0
def main():
    # PID
    global unique

    # user keys
    in_raster = options['input']  # in_raster = 'srtm_1sec_amazonia'
    out_raster = options['output']  # out_raster = 'teste_dnoise'
    iterations = options['iterations']
    threshold = options['threshold']
    epsg = options['epsg']

    # check if input file exists
    if not grass.find_file(in_raster)['file']:
        grass.fatal(_("Raster map <%s> not found") % in_raster)

    # name the files
    tmp_xyz = 'tmp_xyz_%s.xyz' % unique
    tmp_xyz_orig = 'tmp_xyz_%s.xyz' % unique
    tmp_xyz_proj = 'tmp_xyz_proj_%s.xyz' % unique
    tmp_out_dnoise = 'tmp_xyz_dnoise_%s.xyz' % unique
    # tmp_out_dnoise_proj = 'tmp_xyz_dnoise_proj_%s.xyz' % unique
    tmp_xyz_merge = 'tmp_xyz_merge_%s.xyz' % unique
    # list for cleanup
    tmp_rmaps = [
        tmp_xyz, tmp_xyz_orig, tmp_xyz_proj, tmp_out_dnoise, tmp_xyz_merge
    ]

    # Export the map to xyz points.
    grass.message(_("Exporting points..."))
    grass.run_command('r.out.xyz',
                      input=in_raster,
                      output=tmp_xyz,
                      separator='space',
                      overwrite=True)

    # check if current location is in a projected coordinate system
    reproject = check_proj(epsg)

    # Reproject if necessary
    if reproject:
        # define projections
        loc_proj = grass.read_command('g.proj', flags='jf')
        loc_proj = pyproj.Proj(loc_proj.strip())
        epsg_proj = pyproj.Proj(init='epsg:' + str(epsg))
        do_proj(xyz_in=tmp_xyz,
                xyz_out=tmp_xyz_proj,
                in_proj=loc_proj,
                out_proj=epsg_proj)
        tmp_xyz = tmp_xyz_proj

    # Denoise.  The -z flag preserves the xy positions of the points.
    grass.message(_("Denoising..."))
    cmd = ['mdenoise'] + ['-i'] + [tmp_xyz] + ['-t'] + [str(threshold)] + [
        '-n'
    ] + [str(iterations)] + ['-z'] + ['-o'] + [tmp_out_dnoise]
    grass.call(cmd)

    # As only the z coordinates have changed in denoising,
    # the new z coordinates are combined with the original xy coordinates.
    f_merged = open(tmp_xyz_merge, 'w')  # new, merged
    #read input coordinates file
    with open(tmp_out_dnoise) as f_dnoise, open(tmp_xyz_orig) as f_orig:
        for line_dnoise, line_orig in izip(f_dnoise, f_orig):
            xyz_dnoise = line_dnoise.split()  # denoised
            xyz_orig = line_orig.split()  # original
            f_merged.write('%s %s %s\n' %
                           (xyz_orig[0], xyz_orig[1], xyz_dnoise[2]))

    # close files
    f_merged.close()

    # Reload data
    grass.message(_("Reloading data..."))
    grass.run_command('r.in.xyz',
                      flags='i',
                      input=tmp_xyz_merge,
                      output=out_raster,
                      method='min',
                      x=1,
                      y=2,
                      z=3,
                      separator='space',
                      overwrite=True)

    # Edit metadata to record denoising parameters
    grass.run_command('r.support',
                      map=out_raster,
                      title="A denoised version of <%s>" % in_raster)
    grass.run_command(
        'r.support',
        map=out_raster,
        history="Generated by: r.denoise %s iterations=%s threshold=%s" %
        (in_raster, str(threshold), str(iterations)))

    # clean tmp files
    grass.message(_("Removing temporary files..."))
    tmp_rmaps = [
        fname for fname in os.listdir('.') if fname.endswith('%s.xyz' % unique)
    ]
    try:
        for fname in tmp_rmaps:
            os.remove(fname)
    except OSError:
        pass
예제 #19
0
def main():
    # parameters
    infile = options["input"]
    raster_reference = options["raster_reference"]
    raster_file = options["raster_file"]
    outfiles = options["output"]
    resolution = options["resolution"]
    methods = options["method"]
    zrange = options["zrange"]
    zscale = options["zscale"]
    output_type = options["type"]
    percent = options["percent"]
    pth = options["pth"]
    trim = options["trim"]
    footprint = options["footprint"]
    # flags
    scan = flags["s"]
    shell_script_style = flags["g"]

    if len(outfiles.split(",")) != len(methods.split(",")):
        grass.fatal(
            _("Number of outputs <%s> does not match number of methods <%s>" %
              (outfiles, methods)))

    # overwrite auf true setzen
    os.environ["GRASS_OVERWRITE"] = "1"

    # to hide non-error messages from subprocesses
    if grass.verbosity() <= 2:
        outdev = open(os.devnull, "w")
    else:
        outdev = sys.stdout

    # use temporary region
    grass.use_temp_region()

    n, s, w, e, t, b = scan_extent(infile)

    # scan -s or shell_script_style -g:
    if scan:
        if not shell_script_style:
            grass.message(
                _("north: %s\nsouth: %s\nwest: %s\neast: %s\ntop: %s\nbottom: %s"
                  ) % (n, s, w, e, t, b))
        else:
            # shell script style: print to stdout
            print("n=%s s=%s w=%s e=%s t=%s b=%s" % (n, s, w, e, t, b))
    elif footprint:
        footprint_to_vectormap(infile, footprint)
    else:
        # get region with pdal
        # footprint_to_vectormap(infile, 'tiles')

        if raster_file:
            raster_reference = "img" + str(os.getpid())
            grass.run_command("r.external",
                              input=raster_file,
                              flags="o",
                              output=raster_reference)
            result = grass.find_file(name=raster_reference, element="raster")
            if result[u"fullname"] == u"":
                raster_reference = raster_reference + ".1"
        # option 1: set region to extent of tiles while precisely aligning pixel
        # geometry to raster_reference (including both raster_reference and raster_file)
        if raster_reference:
            grass.run_command("g.region",
                              n=n,
                              s=s,
                              e=e,
                              w=w,
                              flags="g",
                              align=raster_reference)
        else:
            # option 2: change raster resolution to final resolution while best
            # effort aligning to pixel geometry
            grass.run_command("g.region",
                              n=n,
                              s=s,
                              e=e,
                              w=w,
                              flags="ap",
                              res=resolution)
        # generate PDAL pipeline
        # . pdal pipline laz2json (STDOUT) | r.in.xyz
        bn = os.path.basename(infile)
        infile_format = bn.split(".")[-1]
        # format_reader from https://pdal.io/stages/readers.html
        format_reader = ""
        if infile_format.lower() == "laz" or infile_format.lower() == "las":
            format_reader = "readers.las"
        # pts: not tested
        elif infile_format.lower() == "pts":
            format_reader = "readers.pts"
        else:
            grass.run_command("g.remove",
                              flags="f",
                              type="vector",
                              name="tiles",
                              quiet=True)
            grass.fatal(_("Format .%s is not supported.." % infile_format))

        grass.message(_("Converting input file <%s>...") % infile)
        tmp_file_json = "tmp_file_json_" + str(os.getpid())

        data = {}
        data["pipeline"] = []
        data["pipeline"].append({"type": format_reader, "filename": infile})
        data["pipeline"].append({
            "type": "writers.text",
            "format": "csv",
            "order": "X,Y,Z",
            "keep_unspecified": "false",
            "filename": "STDOUT",
            "quote_header": "false",
        })
        with open(tmp_file_json, "w") as f:
            json.dump(data, f)

        tmp_xyz = grass.tempfile()
        if tmp_xyz is None:
            grass.fatal("Unable to create temporary files")
        command_pdal1 = options["pdal_cmd"].split(" ")
        if options["pdal_cmd"] != "pdal":
            v_index = None
            cmd_entries = options["pdal_cmd"].split(" ")
            for cmd_entry, num in zip(cmd_entries, range(len(cmd_entries))):
                if cmd_entry == "-v":
                    v_index = num
                    break
            mnt_vol = cmd_entries[v_index + 1].split(":")[1]
            tmp_file_json2 = os.path.join(mnt_vol, tmp_file_json)
        else:
            tmp_file_json2 = tmp_file_json
        command_pdal1.extend(["pipeline", "--input", tmp_file_json2])

        fh = open(tmp_xyz, "wb")
        if grass.call(command_pdal1, stdout=fh) != 0:
            fh.close()
            # check to see if pdal pipeline executed properly
            print(command_pdal1)
            grass.fatal(_("pdal pipeline is broken..."))
        else:
            fh.close()

        for i in range(len(methods.split(","))):
            method = methods.split(",")[i]
            outfile = outfiles.split(",")[i]

            grass.message(_("Generating output raster map <%s>...") % outfile)

            command_pdal2 = [
                "r.in.xyz",
                "input=" + tmp_xyz,
                "output=" + outfile,
                "skip=1",
                "separator=comma",
                "method=" + method,
            ]

            if zrange:
                command_pdal2.append("zrange=" + zrange)
            if zscale:
                command_pdal2.append("zscale=" + zscale)
            if output_type:
                command_pdal2.append("type=" + output_type)
            if percent:
                command_pdal2.append("percent=" + percent)
            if pth:
                command_pdal2.append("pth=" + pth)
            if trim:
                command_pdal2.append("trim=" + trim)

            if grass.call(command_pdal2, stdout=outdev) != 0:
                # check to see if r.in.xyz executed properly
                os.remove(tmp_xyz)
                grass.fatal(_("r.in.xyz is broken..."))

            # metadata
            empty_history = grass.tempfile()
            if empty_history is None:
                grass.fatal("Unable to create temporary files")
            f = open(empty_history, "w")
            f.close()
            grass.run_command(
                "r.support",
                map=outfile,
                source1=infile,
                description="generated by r.in.pdal",
                loadhistory=empty_history,
            )
            grass.run_command("r.support",
                              map=outfile,
                              history=os.environ["CMDLINE"])
            os.remove(empty_history)

        # Cleanup
        grass.message(_("Cleaning up..."))
        grass.run_command("g.remove",
                          flags="f",
                          type="vector",
                          name="tiles",
                          quiet=True)
        if raster_file:
            grass.run_command(
                "g.remove",
                flags="f",
                type="raster",
                pattern=raster_reference[:-1] + "*",
                quiet=True,
            )
        os.remove(tmp_file_json)
        os.remove(tmp_xyz)
        grass.del_temp_region()
예제 #20
0
def scan_extent(infile):
    if not grass.find_program(
            options["pdal_cmd"].split(" ")[0],
            " ".join(options["pdal_cmd"].split(" ")[1:]) + " info --summary",
    ):
        grass.fatal(
            _("The pdal program is not in the path " +
              "and executable. Please install first"))
    command_scan = options["pdal_cmd"].split(" ")
    command_scan.extend(["info", "--summary", infile])

    tmp_scan = grass.tempfile()
    if tmp_scan is None:
        grass.fatal("Unable to create temporary files")
    fh = open(tmp_scan, "wb")
    summary = True
    if grass.call(command_scan, stdout=fh) != 0:
        fh.close()
        command_scan = options["pdal_cmd"].split(" ")
        command_scan.extend(["info", infile])
        fh2 = open(tmp_scan, "wb")
        if grass.call(command_scan, stdout=fh2) != 0:
            os.remove(tmp_scan)
            grass.fatal(
                _("pdal cannot determine metadata " +
                  "for unsupported format of <%s>") % infile)
            fh2.close()
        else:
            fh2.close()
        summary = False
    else:
        fh.close()

    data = json.load(open(tmp_scan))
    if summary:
        str1 = u"summary"
        str2 = u"bounds"
        y_str = u"Y"
        x_str = u"X"
        z_str = u"Z"
        min_str = u"min"
        max_str = u"max"
        try:
            n = str(data[str1][str2][y_str][max_str])
            s = str(data[str1][str2][y_str][min_str])
            w = str(data[str1][str2][x_str][min_str])
            e = str(data[str1][str2][x_str][max_str])
            t = str(data[str1][str2][z_str][max_str])
            b = str(data[str1][str2][z_str][min_str])
        except:
            ymin_str = u"miny"
            xmin_str = u"minx"
            zmin_str = u"minz"
            ymax_str = u"maxy"
            xmax_str = u"maxx"
            zmax_str = u"maxz"
            n = str(data[str1][str2][ymax_str])
            s = str(data[str1][str2][ymin_str])
            w = str(data[str1][str2][xmin_str])
            e = str(data[str1][str2][xmax_str])
            t = str(data[str1][str2][zmax_str])
            b = str(data[str1][str2][zmin_str])
    else:
        str1 = u"stats"
        str2 = u"bbox"
        str3 = u"native"
        str4 = u"bbox"
        n = str(data[str1][str2][str3][str4][u"maxy"])
        s = str(data[str1][str2][str3][str4][u"miny"])
        w = str(data[str1][str2][str3][str4][u"minx"])
        e = str(data[str1][str2][str3][str4][u"maxx"])
        t = str(data[str1][str2][str3][str4][u"maxz"])
        b = str(data[str1][str2][str3][str4][u"minz"])

    return n, s, w, e, t, b