[GRASS-SVN] r63676 - grass/branches/releasebranch_7_0/scripts/r.tileset
svn_grass at osgeo.org
svn_grass at osgeo.org
Mon Dec 22 10:00:07 PST 2014
Author: lucadelu
Date: 2014-12-22 10:00:07 -0800 (Mon, 22 Dec 2014)
New Revision: 63676
Modified:
grass/branches/releasebranch_7_0/scripts/r.tileset/r.tileset.py
Log:
r.tileset: added some check for possible errors, PEP8 cleanup backport r62923 r62924
Modified: grass/branches/releasebranch_7_0/scripts/r.tileset/r.tileset.py
===================================================================
--- grass/branches/releasebranch_7_0/scripts/r.tileset/r.tileset.py 2014-12-22 17:19:29 UTC (rev 63675)
+++ grass/branches/releasebranch_7_0/scripts/r.tileset/r.tileset.py 2014-12-22 18:00:07 UTC (rev 63676)
@@ -108,13 +108,14 @@
# A projection - [0] is proj.4 text, [1] is scale
import sys
-import subprocess
import tempfile
import math
from grass.script.utils import separator
from grass.script import core as grass
+from grass.exceptions import CalledModuleError
+
def bboxToPoints(bbox):
"""Make points that are the corners of a bounding box"""
points = []
@@ -122,9 +123,10 @@
points.append((bbox['w'], bbox['n']))
points.append((bbox['e'], bbox['n']))
points.append((bbox['e'], bbox['s']))
-
+
return points
+
def pointsToBbox(points):
bbox = {}
min_x = min_y = max_x = max_y = None
@@ -133,7 +135,7 @@
min_x = max_x = point[0]
if not min_y:
min_y = max_y = point[1]
-
+
if min_x > point[0]:
min_x = point[0]
if max_x < point[0]:
@@ -142,49 +144,58 @@
min_y = point[1]
if max_y < point[1]:
max_y = point[1]
-
+
bbox['n'] = max_y
bbox['s'] = min_y
bbox['w'] = min_x
bbox['e'] = max_x
-
+
return bbox
+
def project(file, source, dest):
"""Projects point (x, y) using projector"""
+ errors = 0
points = []
- ret = grass.read_command('m.proj',
- quiet = True,
- flags = 'd',
- proj_in = source['proj'],
- proj_out = dest['proj'],
- sep = ';',
- input = file)
-
+ try:
+ ret = grass.read_command('m.proj',
+ quiet=True,
+ flags='d',
+ proj_in=source['proj'],
+ proj_out=dest['proj'],
+ sep=';',
+ input=file)
+ except CalledModuleError:
+ grass.fatal(cs2cs + ' failed')
+
if not ret:
grass.fatal(cs2cs + ' failed')
-
+
for line in ret.splitlines():
- p_x2, p_y2, p_z2 = map(float, line.split(';'))
- points.append((p_x2 / dest['scale'], p_y2 / dest['scale']))
-
- return points
-
+ if "*" in line:
+ errors += 1
+ else:
+ p_x2, p_y2, p_z2 = map(float, line.split(';'))
+ points.append((p_x2 / dest['scale'], p_y2 / dest['scale']))
+
+ return points, errors
+
+
def projectPoints(points, source, dest):
"""Projects a list of points"""
dest_points = []
-
+
input = tempfile.NamedTemporaryFile(mode="wt")
for point in points:
- input.file.write('%f;%f\n' % \
- (point[0] * source['scale'],
- point[1] * source['scale']))
+ input.file.write('%f;%f\n' % (point[0] * source['scale'],
+ point[1] * source['scale']))
input.file.flush()
-
- dest_points = project(input.name, source, dest)
-
- return dest_points
+ dest_points, errors = project(input.name, source, dest)
+
+ return dest_points, errors
+
+
def sideLengths(points, xmetric, ymetric):
"""Find the length of sides of a set of points from one to the next"""
ret = []
@@ -197,10 +208,10 @@
sl_y = (points[j][1] - points[i][1]) * ymetric
sl_d = math.sqrt(sl_x * sl_x + sl_y * sl_y)
ret.append(sl_d)
-
- return { 'x' : (ret[1], ret[3]),
- 'y' : (ret[0], ret[2]) }
+ return {'x': (ret[1], ret[3]), 'y': (ret[0], ret[2])}
+
+
def bboxesIntersect(bbox_1, bbox_2):
"""Determine if two bounding boxes intersect"""
bi_a1 = (bbox_1['w'], bbox_1['s'])
@@ -210,37 +221,46 @@
cin = [False, False]
for i in (0, 1):
if (bi_a1[i] <= bi_b1[i] and bi_a2[i] >= bi_b1[i]) or \
- (bi_a1[i] <= bi_b1[i] and bi_a2[i] >= bi_b2[i]) or \
- (bi_b1[i] <= bi_a1[i] and bi_b2[i] >= bi_a1[i]) or \
- (bi_b1[i] <= bi_a1[i] and bi_b2[i] >= bi_a2[i]):
+ (bi_a1[i] <= bi_b1[i] and bi_a2[i] >= bi_b2[i]) or \
+ (bi_b1[i] <= bi_a1[i] and bi_b2[i] >= bi_a1[i]) or \
+ (bi_b1[i] <= bi_a1[i] and bi_b2[i] >= bi_a2[i]):
cin[i] = True
-
+
if cin[0] and cin[1]:
return True
-
+
return False
+
def main():
# Take into account those extra pixels we'll be a addin'
max_cols = int(options['maxcols']) - int(options['overlap'])
max_rows = int(options['maxrows']) - int(options['overlap'])
-
+
+ if max_cols == 0:
+ grass.fatal(_("It is not possibile to set 'maxcols=%s' and "
+ "'overlap=%s'. Please set maxcols>overlap" %
+ (options['maxcols'], options['overlap'])))
+ elif max_rows == 0:
+ grass.fatal(_("It is not possibile to set 'maxrows=%s' and "
+ "'overlap=%s'. Please set maxrows>overlap" %
+ (options['maxrows'], options['overlap'])))
# destination projection
if not options['destproj']:
dest_proj = grass.read_command('g.proj',
- quiet = True,
- flags = 'jf').rstrip('\n')
+ quiet=True,
+ flags='jf').rstrip('\n')
if not dest_proj:
grass.fatal(_('g.proj failed'))
else:
dest_proj = options['destproj']
grass.debug("Getting destination projection -> '%s'" % dest_proj)
-
+
# projection scale
if not options['destscale']:
ret = grass.parse_command('g.proj',
- quiet = True,
- flags = 'j')
+ quiet=True,
+ flags='j')
if not ret:
grass.fatal(_('g.proj failed'))
@@ -252,17 +272,16 @@
else:
dest_scale = options['destscale']
grass.debug('Getting destination projection scale -> %s' % dest_scale)
-
+
# set up the projections
- srs_source = { 'proj' : options['sourceproj'],
- 'scale' : float(options['sourcescale']) }
- srs_dest = { 'proj' : dest_proj,
- 'scale' : float(dest_scale) }
-
+ srs_source = {'proj': options['sourceproj'],
+ 'scale': float(options['sourcescale'])}
+ srs_dest = {'proj': dest_proj, 'scale': float(dest_scale)}
+
if options['region']:
grass.run_command('g.region',
- quiet = True,
- region = options['region'])
+ quiet=True,
+ region=options['region'])
dest_bbox = grass.region()
grass.debug('Getting destination region')
@@ -272,52 +291,57 @@
# project the destination region into the source:
grass.verbose('Projecting destination region into source...')
dest_bbox_points = bboxToPoints(dest_bbox)
-
- dest_bbox_source_points = projectPoints(dest_bbox_points,
- source = srs_dest,
- dest = srs_source)
-
+
+ dest_bbox_source_points, errors_dest = projectPoints(dest_bbox_points,
+ source=srs_dest,
+ dest=srs_source)
+
+ if len(dest_bbox_source_points) == 0:
+ grass.fatal(_("There are no tiles available. Probably the output "
+ "projection system it is not compatible with the "
+ "projection of the current location"))
+
source_bbox = pointsToBbox(dest_bbox_source_points)
-
+
grass.verbose('Projecting source bounding box into destination...')
-
+
source_bbox_points = bboxToPoints(source_bbox)
-
- source_bbox_dest_points = projectPoints(source_bbox_points,
- source = srs_source,
- dest = srs_dest)
-
+
+ source_bbox_dest_points, errors_source = projectPoints(source_bbox_points,
+ source=srs_source,
+ dest=srs_dest)
+
x_metric = 1 / dest_bbox['ewres']
y_metric = 1 / dest_bbox['nsres']
-
+
grass.verbose('Computing length of sides of source bounding box...')
-
+
source_bbox_dest_lengths = sideLengths(source_bbox_dest_points,
x_metric, y_metric)
-
+
# Find the skewedness of the two directions.
# Define it to be greater than one
# In the direction (x or y) in which the world is least skewed (ie north south in lat long)
# Divide the world into strips. These strips are as big as possible contrained by max_
# In the other direction do the same thing.
# Theres some recomputation of the size of the world that's got to come in here somewhere.
-
+
# For now, however, we are going to go ahead and request more data than is necessary.
# For small regions far from the critical areas of projections this makes very little difference
# in the amount of data gotten.
# We can make this efficient for big regions or regions near critical points later.
-
+
bigger = []
bigger.append(max(source_bbox_dest_lengths['x']))
bigger.append(max(source_bbox_dest_lengths['y']))
maxdim = (max_cols, max_rows)
-
+
# Compute the number and size of tiles to use in each direction
# I'm making fairly even sized tiles
# They differer from each other in height and width only by one cell
# I'm going to make the numbers all simpler and add this extra cell to
# every tile.
-
+
grass.message(_('Computing tiling...'))
tiles = [-1, -1]
tile_base_size = [-1, -1]
@@ -326,62 +350,70 @@
tileset_size = [-1, -1]
tile_size_overlap = [-1, -1]
for i in range(len(bigger)):
- # make these into integers.
- # round up
- bigger[i] = int(bigger[i] + 1)
- tiles[i] = int((bigger[i] / maxdim[i]) + 1)
+ # make these into integers.
+ # round up
+ bigger[i] = int(bigger[i] + 1)
+ tiles[i] = int((bigger[i] / maxdim[i]) + 1)
tile_size[i] = tile_base_size[i] = int(bigger[i] / tiles[i])
- tiles_extra_1[i] = int(bigger[i] % tiles[i])
- # This is adding the extra pixel (remainder) to all of the tiles:
+ tiles_extra_1[i] = int(bigger[i] % tiles[i])
+ # This is adding the extra pixel (remainder) to all of the tiles:
if tiles_extra_1[i] > 0:
tile_size[i] = tile_base_size[i] + 1
tileset_size[i] = int(tile_size[i] * tiles[i])
- # Add overlap to tiles (doesn't effect tileset_size
+ # Add overlap to tiles (doesn't effect tileset_size
tile_size_overlap[i] = tile_size[i] + int(options['overlap'])
-
- grass.verbose("There will be %d by %d tiles each %d by %d cells" % \
+
+ grass.verbose("There will be %d by %d tiles each %d by %d cells" %
(tiles[0], tiles[1], tile_size[0], tile_size[1]))
-
+
ximax = tiles[0]
yimax = tiles[1]
-
+
min_x = source_bbox['w']
min_y = source_bbox['s']
max_x = source_bbox['e']
max_y = source_bbox['n']
span_x = (max_x - min_x)
span_y = (max_y - min_y)
-
+
xi = 0
- tile_bbox = { 'w' : -1, 's': -1, 'e' : -1, 'n' : -1 }
+ tile_bbox = {'w': -1, 's': -1, 'e': -1, 'n': -1}
+
+ if errors_dest > 0:
+ grass.warning(_("During computation %i tiles could not be created" %
+ errors_dest))
+
while xi < ximax:
tile_bbox['w'] = float(min_x) + (float(xi) * float(tile_size[0]) / float(tileset_size[0])) * float(span_x)
tile_bbox['e'] = float(min_x) + (float(xi + 1) * float(tile_size_overlap[0]) / float(tileset_size[0])) * float(span_x)
- yi = 0
+ yi = 0
while yi < yimax:
tile_bbox['s'] = float(min_y) + (float(yi) * float(tile_size[1]) / float(tileset_size[1])) * float(span_y)
tile_bbox['n'] = float(min_y) + (float(yi + 1) * float(tile_size_overlap[1]) / float(tileset_size[1])) * float(span_y)
tile_bbox_points = bboxToPoints(tile_bbox)
- tile_dest_bbox_points = projectPoints(tile_bbox_points,
- source = srs_source,
- dest = srs_dest)
+ tile_dest_bbox_points, errors = projectPoints(tile_bbox_points,
+ source=srs_source,
+ dest=srs_dest)
tile_dest_bbox = pointsToBbox(tile_dest_bbox_points)
if bboxesIntersect(tile_dest_bbox, dest_bbox):
if flags['w']:
print "bbox=%s,%s,%s,%s&width=%s&height=%s" % \
- (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'], tile_bbox['n'],
- tile_size_overlap[0], tile_size_overlap[1])
+ (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'],
+ tile_bbox['n'], tile_size_overlap[0],
+ tile_size_overlap[1])
elif flags['g']:
print "w=%s;s=%s;e=%s;n=%s;cols=%s;rows=%s" % \
- (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'], tile_bbox['n'],
- tile_size_overlap[0], tile_size_overlap[1])
+ (tile_bbox['w'], tile_bbox['s'], tile_bbox['e'],
+ tile_bbox['n'], tile_size_overlap[0],
+ tile_size_overlap[1])
else:
print "%s%s%s%s%s%s%s%s%s%s%s" % \
- (tile_bbox['w'], fs, tile_bbox['s'], fs, tile_bbox['e'], fs, tile_bbox['n'], fs,
+ (tile_bbox['w'], fs, tile_bbox['s'], fs,
+ tile_bbox['e'], fs, tile_bbox['n'], fs,
tile_size_overlap[0], fs, tile_size_overlap[1])
yi += 1
xi += 1
-
+
if __name__ == "__main__":
cs2cs = 'cs2cs'
options, flags = grass.parser()
More information about the grass-commit
mailing list