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