Пример #1
0
def main():
    global gisbase, browser, browser_name

    index = flags["i"]
    manual = flags["m"]
    entry = options["entry"]

    gisbase = os.environ["GISBASE"]

    browser = os.getenv("GRASS_HTML_BROWSER")

    if sys.platform == "darwin":
        # hack for MacOSX
        browser_name = os.getenv("GRASS_HTML_BROWSER_MACOSX", "..").split(".")[2]
    elif sys.platform == "cygwin":
        # hack for Cygwin
        browser_name = grass.basename(browser, "exe")
    else:
        browser_name = grass.basename(browser)

        # keep order!
        # first test for index...
    if index:
        if manual:
            start_man("index")
        else:
            start_browser("index")
        return 0

    if manual:
        start_man(entry)
    else:
        start_browser(entry)
    return 0
Пример #2
0
def main():
    input = options['input']
    format = options['format']
    dsn = options['dsn']
    table = options['table']

    if format.lower() == 'dbf':
	format = "ESRI_Shapefile"

    if format.lower() == 'csv':
	olayer = grass.basename(dsn, 'csv')
    else:
	olayer = None

    #is there a simpler way of testing for --overwrite?
    dbffile = input + '.dbf'
    if os.path.exists(dbffile) and not grass.overwrite():
	grass.fatal(_("File <%s> already exists") % dbffile)

    if olayer:
	if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn,
			     format = format, type = 'point', olayer = olayer) != 0:
	    sys.exit(1)
    else:
	if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn,
			     format = format, type = 'point') != 0:
	    sys.exit(1)

    if format == "ESRI_Shapefile":
	exts = ['shp', 'shx', 'prj']
	if dsn.endswith('.dbf'):
	    outname = grass.basename(dsn, 'dbf')
	    for ext in exts:
		grass.try_remove("%s.%s" % (outname, ext))
	    outname += '.dbf'
	else:
	    for ext in exts:
		grass.try_remove(os.path.join(dsn, "%s.%s" % (input, ext)))
	    outname = os.path.join(dsn, input + ".dbf")
    elif format.lower() == 'csv':
	outname = dsn + '.csv'
    else:
	outname = input

    grass.message(_("Exported table <%s>") % outname)
Пример #3
0
def main():
    fileorig = options['input']
    filevect = options['output']
    
    if not filevect:
	filevect = grass.basename(fileorig, 'txt')

    #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/WGS84 locations"))

    #### setup temporary file
    tmpfile = grass.tempfile()

    coldescs = [("RC",		"rc integer"),
		("UFI",		"uf1 integer"),
		("UNI",		"uni integer"),
		("LAT",		"lat double precision"),
		("LONG",	"lon double precision"),
		("DMS_LAT",	"dms_lat varchar(6)"),
		("DMS_LONG",	"dms_long varchar(7)"),
		("UTM",		"utm varchar(4)"),
		("JOG",		"jog varchar(7)"),
		("FC",		"fc varchar(1)"),
		("DSG",		"dsg varchar(5)"),
		("PC",		"pc integer"),
		("CC1",		"cci varchar(2)"),
		("ADM1",	"adm1 varchar(2)"),
		("ADM2",	"adm2 varchar(200)"),
		("DIM",		"dim integer"),
		("CC2",		"cc2 varchar(2)"),
		("NT",		"nt varchar(1)"),
		("LC",		"lc varchar(3)"),
		("SHORT_FORM",	"shortform varchar(128)"),
		("GENERIC",	"generic varchar(128)"),
		("SORT_NAME",	"sortname varchar(200)"),
		("FULL_NAME",	"fullname varchar(200)"),
		("FULL_NAME_ND","funamesd varchar(200)"),
		("MODIFY_DATE",	"mod_date date")]

    colnames = [desc[0] for desc in coldescs]
    coltypes = dict([(desc[0], 'integer' in desc[1]) for desc in coldescs])

    header = None
    num_places = 0
    inf = file(fileorig)
    outf = file(tmpfile, 'wb')
    for line in inf:
	fields = line.rstrip('\r\n').split('\t')
	if not header:
	    header = fields
	    continue
	vars = dict(zip(header, fields))
	fields2 = []
	for col in colnames:
	    if col in vars:
		if coltypes[col] and vars[col] == '':
		    fields2.append('0')
		else:
		    fields2.append(vars[col])
	    else:
		if coltypes[col]:
		    fields2.append('0')
		else:
		    fields2.append('')
	line2 = ';'.join(fields2) + '\n'
	outf.write(line2)
	num_places += 1
    outf.close()
    inf.close()

    grass.message(_("Converted %d place names.") % num_places)

    #TODO: fix dms_lat,dms_long DDMMSS -> DD:MM:SS
    # Solution:
    # IN=DDMMSS
    # DEG=`echo $IN | cut -b1,2`
    # MIN=`echo $IN | cut -b3,4`
    # SEC=`echo $IN | cut -b5,6`
    # DEG_STR="$DEG:$MIN:$SEC"
    
    #modifications (to match DBF 10 char column name limit):
    # short_form   -> shortform
    # sort_name    -> sortname
    # full_name    -> fullname
    # full_name_sd -> funamesd

    # pump data into GRASS:

    columns = [desc[1] for desc in coldescs]

    grass.run_command('v.in.ascii', cat = 0, x = 5, y = 4, fs = ';',
		      input = tmpfile, output = filevect,
		      columns = columns)

    grass.try_remove(tmpfile)

    # write cmd history:
    vgrass.vector_history(filevect)
Пример #4
0
def main():
    filename = options['file']
    type = options['type']
    vect = options['vect']

    e00tmp = str(os.getpid())

    #### check for avcimport
    if not grass.find_program('avcimport'):
	grass.fatal(_("'avcimport' program not found, install it first") +
		    "\n" +
		    "http://avce00.maptools.org")

    #### check for e00conv
    if not grass.find_program('e00conv'):
	grass.fatal(_("'e00conv' program not found, install it first") +
		    "\n" +
		    "http://avce00.maptools.org")

    # check that the user didn't use all three, which gets past the parser.
    if type not in ['point','line','area']:
	grass.fatal(_('Must specify one of "point", "line", or "area".'))

    e00name = grass.basename(filename, 'e00')
    # avcimport only accepts 13 chars:
    e00shortname = e00name[:13]

    #check if this is a split E00 file (.e01, .e02 ...):
    merging = False
    if os.path.exists(e00name + '.e01') or os.path.exists(e00name + '.E01'):
	grass.message(_("Found that E00 file is split into pieces (.e01, ...). Merging..."))
	merging = True

    if vect:
	name = vect
    else:
	name = e00name

    ### do import

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

    files = glob.glob(e00name + '.e[0-9][0-9]') + glob.glob(e00name + '.E[0-9][0-9]')
    for f in files:
	shutil.copy(f, tmpdir)

    #change to temporary directory to later avoid removal problems (rm -r ...)
    os.chdir(tmpdir)

    #check for binay E00 file (we can just check if import fails):
    #avcimport doesn't set exist status :-(

    if merging:
	files.sort()
	filename = "%s.cat.%s.e00" % (e00name, e00tmp)
	outf = file(filename, 'wb')
	for f in files:
	    inf = file(f, 'rb')
	    shutil.copyfileobj(inf, outf)
	    inf.close()
	outf.close()

    nuldev = file(os.devnull, 'w+')

    grass.message(_("An error may appear next which will be ignored..."))
    if grass.call(['avcimport', filename, e00shortname], stdout = nuldev, stderr = nuldev) == 1:
	grass.message(_("E00 ASCII found and converted to Arc Coverage in current directory"))
    else:
	grass.message(_("E00 Compressed ASCII found. Will uncompress first..."))
	grass.try_remove(e00shortname)
	grass.try_remove(info)
	grass.call(['e00conv', filename, e00tmp + '.e00'])
	grass.message(_("...converted to Arc Coverage in current directory"))
	grass.call(['avcimport', e00tmp + '.e00', e00shortname], stderr = nuldev)

    #SQL name fix:
    name = name.replace('-', '_')

    ## let's import...
    grass.message(_("Importing %ss...") % type)

    layer = dict(point = 'LAB', line = 'ARC', area = ['LAB','ARC'])
    itype = dict(point = 'point', line = 'line', area = 'centroid')

    if grass.run_command('v.in.ogr', flags = 'o', dsn = e00shortname,
			 layer = layer[type], type = itype[type],
			 output = name) != 0:
	grass.fatal(_("An error occurred while running v.in.ogr"))

    grass.message(_("Imported <%s> vector map <%s>.") % (type, name))

    #### clean up the mess
    for root, dirs, files in os.walk('.', False):
	for f in files:
	    path = os.path.join(root, f)
	    grass.try_remove(path)
	for d in dirs:
	    path = os.path.join(root, d)
	    grass.try_rmdir(path)

    os.chdir('..')
    os.rmdir(tmpdir)
	
    #### end
    grass.message(_("Done."))

    # write cmd history:
    grass.vector_history(name)
Пример #5
0
def main():
    global tmp
    global sine_cosine_replic, outercircle, vector
    global totalvalidnumber, totalnumber, maxradius

    map = options['map']
    undef = options['undef']
    eps = options['eps']
    xgraph = flags['x']

    tmp = grass.tempfile()

    if eps and xgraph:
	grass.fatal(_("Please select only one output method"))

    #### check if we have xgraph (if no EPS output requested)
    if xgraph and not grass.find_program('xgraph'):
	grass.fatal(_("xgraph required, please install first (www.xgraph.org)"))

    #################################
    # this file contains everthing:
    rawfile = tmp + "_raw"
    rawf = file(rawfile, 'w')
    grass.run_command('r.stats', flags = '1', input = map, stdout = rawf)
    rawf.close()

    rawf = file(rawfile)
    totalnumber = 0
    for line in rawf:
	totalnumber += 1
    rawf.close()

    grass.message(_("Calculating statistics for polar diagram... (be patient)"))

    #wipe out NULL data and undef data if defined by user
    # - generate degree binned to integer, eliminate NO DATA (NULL):
    # change 360 to 0 to close polar diagram:
    rawf = file(rawfile)
    nvals = 0
    sumcos = 0
    sumsin = 0
    freq = {}
    for line in rawf:
	line = line.rstrip('\r\n')
	if line in ['*', undef]:
	    continue
	nvals += 1
	x = float(line)
	rx = math.radians(x)
	sumcos += math.cos(rx)
	sumsin += math.sin(rx)
	ix = round(x)
	if ix == 360:
	    ix = 0
	if ix in freq:
	    freq[ix] += 1
	else:
	    freq[ix] = 1
    rawf.close()

    totalvalidnumber = nvals
    if totalvalidnumber == 0:
	grass.fatal(_("No data pixel found"))

    #################################
    # unit vector on raw data converted to radians without no data:

    unitvector = (sumcos / nvals, sumsin / nvals)

    #################################
    # how many are there?:

    occurrences = [(math.radians(x), freq[x]) for x in freq]
    occurrences.sort()
    
    # find the maximum value
    maxradius = max([f for a, f in occurrences])

    # now do cos() sin()
    sine_cosine = [(math.cos(a) * f, math.sin(a) * f) for a, f in occurrences]

    sine_cosine_replic = ['"Real data angles'] + sine_cosine + sine_cosine[0:1]

    if eps or xgraph:
	outercircle = []
	outercircle.append('"All Data incl. NULLs')
	scale = 1.0 * totalnumber / totalvalidnumber * maxradius
	for i in range(0, 361):
	    a = math.radians(i)
	    x = math.cos(a) * scale
	    y = math.sin(a) * scale
	    outercircle.append((x, y))

    # fix vector length to become visible (x? of $MAXRADIUS):
    vector = []
    vector.append('"Avg. Direction\n')
    vector.append((0, 0))
    vector.append((unitvector[0] * maxradius, unitvector[1] * maxradius))

    ###########################################################

    # Now output:

    if eps:
	psout = grass.basename(eps, 'eps') + '.eps'
	plot_eps(psout)
    elif xgraph:
	plot_xgraph()
    else:
	plot_dgraph()

    grass.message(_("Average vector:"))
    grass.message(_("direction: %.1f degrees CCW from East") % math.degrees(math.atan2(unitvector[1], unitvector[0])))
    grass.message(_("magnitude: %.1f percent of fullscale") % (100 * math.hypot(unitvector[0], unitvector[1])))