Altered so that xy_extent/corners are in pixel space and latlon are GCS. To add, proj space (dc6fcc74) · Commits · aflab / astrogeology / Autocnet

autocnet/fileio/io_gdal.py

+48 −62

Original line number	Original line	Diff line number	Diff line
	@@ -151,6 +151,8 @@ class GeoDataset(object):
	if self.dataset is None:		if self.dataset is None:
	raise IOError('File not found :', file_name)		raise IOError('File not found :', file_name)



	def __repr__(self):		def __repr__(self):
	return os.path.basename(self.file_name)		return os.path.basename(self.file_name)

	@@ -206,26 +208,6 @@ class GeoDataset(object):
	self._gcs = self.spatial_reference.CloneGeogCS()		self._gcs = self.spatial_reference.CloneGeogCS()
	return self._gcs		return self._gcs

	@property
	def latlon_extent(self):
	if not getattr(self, '_latlon_extent', None):
	if self.footprint:
	fp = self.footprint
	# If we have a footprint, do not worry about computing a lat/lon transform
	lowerlat, upperlat, lowerlon, upperlon = fp.GetEnvelope()
	self._footprint = [(upperlat, lowerlon),
	(lowerlat, lowerlon),
	(lowerlat, upperlon),
	(upperlat, upperlon)]
	else:
	xy_corners = self.xy_corners
	self._latlon_extent = []
	self.coordinate_transformation
	for x, y in xy_corners:
	x, y = self.pixel_to_latlon(x,y)
	self._latlon_extent.append((x,y))
	return self._latlon_extent

	@property		@property
	def metadata(self):		def metadata(self):
	if not hasattr(self, '_metadata'):		if not hasattr(self, '_metadata'):
	@@ -255,54 +237,58 @@ class GeoDataset(object):
	return self._footprint		return self._footprint

	@property		@property
	def xy_corners(self):		def latlon_corners(self):
	if not getattr(self, '_xy_corners', None):		if not getattr(self, '_latlon_corners', None):
	self._xy_corners = []		pixel_corners = self.xy_corners

	gt = self.geotransform		gt = self.geotransform
	x = [0, self.dataset.RasterXSize]
	y = [0, self.dataset.RasterYSize]

	for px in x:		self._latlon_corners = []
	for py in y:
	xc = gt[0] + (px * gt[1]) + (py * gt[2])		for x, y in pixel_corners:
	yc = gt[3] + (px * gt[4]) + (py * gt[5])		x, y = self.pixel_to_latlon(x, y)
	self._xy_corners.append((xc, yc))		self._latlon_corners.append((x, y))
	y.reverse()		return self._latlon_corners
	return self._xy_corners

	@property		@property
	def xy_extent(self):		def xy_corners(self):
	if not getattr(self, '_xy_extent', None):		return [(0, 0),
	geotransform = self.geotransform		(0, self.dataset.RasterYSize),
	minx = geotransform[0]		(self.dataset.RasterXSize,self.dataset.RasterYSize),
	miny = geotransform[3]		(self.dataset.RasterXSize, 0)]

	maxx = minx + geotransform[1] * self.dataset.RasterXSize		@property
	maxy = miny + geotransform[5] * self.dataset.RasterYSize		def proj_corners(self):
			# The corner coordinates in projected space
			raise NotImplementedError

	self._xy_extent = [(minx, miny), (maxx, maxy)]		@property
			def latlon_extent(self):
			if not getattr(self, '_latlon_extent', None):
			if self.footprint:
			fp = self.footprint
			# If we have a footprint, do not worry about computing a lat/lon transform
			lowerlat, upperlat, lowerlon, upperlon = fp.GetEnvelope()
			self._footprint = [(upperlat, lowerlon),
			(lowerlat, lowerlon),
			(lowerlat, upperlon),
			(upperlat, upperlon)]
			else:
			self._latlon_extent = []
			for x, y in self.xy_extent:
			x, y = self.pixel_to_latlon(x,y)

	return self._xy_extent		self._latlon_extent.append((x,y))
			return self._latlon_extent

	@property		@property
	def pixel_polygon(self):		def xy_extent(self):
	"""		return [(0, 0),
	A bounding polygon in pixel space		(self.dataset.RasterXSize, self.dataset.RasterYSize)]

	Returns		@property
	-------		def proj_extent(self):
	: object		# The extent in projected space
	A PySAL Polygon object		raise NotImplementedError
	"""
	if not getattr(self, '_pixel_polygon', None):
	(minx, miny), (maxx, maxy) = self.xy_extent
	ul = maxx, miny
	ll = minx, miny
	lr = minx, maxy
	ur = maxx, maxy
	self._pixel_polygon = Polygon([ul, ll, lr, ur, ul])
	return self._pixel_polygon

	@property		@property
	def pixel_area(self):		def pixel_area(self):
	@@ -400,9 +386,9 @@ class GeoDataset(object):

	"""		"""
	try:		try:
	#geotransform = self.geotransform		geotransform = self.geotransform
	#x = geotransform[0] + (x * geotransform[1]) + (y * geotransform[2])		x = geotransform[0] + (x * geotransform[1]) + (y * geotransform[2])
	#y = geotransform[3] + (x * geotransform[4]) + (y * geotransform[5])		y = geotransform[3] + (x * geotransform[4]) + (y * geotransform[5])
	lon, lat, _ = self.coordinate_transformation.TransformPoint(x, y)		lon, lat, _ = self.coordinate_transformation.TransformPoint(x, y)
	except:		except:
	lat = lon = None		lat = lon = None

autocnet/fileio/tests/test_io_gdal.py

+11 −22

Original line number	Original line	Diff line number	Diff line
	@@ -22,14 +22,14 @@ class TestMercator(unittest.TestCase):
	self.assertEqual(self.dataset.unit_type, '')		self.assertEqual(self.dataset.unit_type, '')

	def test_get_xy_extent(self):		def test_get_xy_extent(self):
	self.assertEqual(self.dataset.xy_extent, [(0.0, 3921610.0), (10667520.0, -3921610.0)])		self.assertEqual(self.dataset.xy_extent, [(0, 0), (2304, 1694)])

	def test_get_no_data_value(self):		def test_get_no_data_value(self):
	self.assertEqual(self.dataset.no_data_value, 0.0)		self.assertEqual(self.dataset.no_data_value, 0.0)

	def test_pixel_to_latlon(self):		def test_pixel_to_latlon(self):
	lat, lon = self.dataset.pixel_to_latlon(0, 0)		lat, lon = self.dataset.pixel_to_latlon(0, 0)
	self.assertAlmostEqual(lat, 0.0, 6)		self.assertAlmostEqual(lat, 55.3322890, 6)
	self.assertAlmostEqual(lon, 0.0, 6)		self.assertAlmostEqual(lon, 0.0, 6)

	def test_scale(self):		def test_scale(self):
	@@ -37,18 +37,15 @@ class TestMercator(unittest.TestCase):

	def test_xy_extent(self):		def test_xy_extent(self):
	xy_extent = self.dataset.xy_extent		xy_extent = self.dataset.xy_extent
	self.assertEqual(xy_extent, [(0.0, 3921610.0), (10667520.0, -3921610.0)])		self.assertEqual(xy_extent, [(0, 0), (2304, 1694)])

	def test_xy_corners(self):		def test_xy_corners(self):
	xy_corners = self.dataset.xy_corners		xy_corners = self.dataset.xy_corners
	self.assertEqual(xy_corners, [(0.0, 3921610.0), (0.0, -3921610.0),		self.assertEqual(xy_corners, [(0, 0), (0, 1694), (2304, 1694), (2304, 0)])
	(10667520.0, -3921610.0), (10667520.0, 3921610.0)])

	def test_latlon_extent(self):		def test_latlon_extent(self):
	self.assertEqual(self.dataset.latlon_extent, [(55.33228905180849, 0.0),		self.assertEqual(self.dataset.latlon_extent, [(55.33228905180849, 0.0),
	(-55.3322890518085, 0.0),		(-55.3322890518085, 179.96751473604124)])
	(-55.3322890518085, 179.96751473604124),
	(55.33228905180849, 179.96751473604124)])

	def test_spheroid(self):		def test_spheroid(self):
	sphere = self.dataset.spheroid		sphere = self.dataset.spheroid
	@@ -106,15 +103,15 @@ class TestLambert(unittest.TestCase):
	self.assertEqual(self.dataset.unit_type, '')		self.assertEqual(self.dataset.unit_type, '')

	def test_get_xy_extent(self):		def test_get_xy_extent(self):
	self.assertEqual(self.dataset.xy_extent, [(-464400.0, -506970.0), (460530.0, -1571220.0)])		self.assertEqual(self.dataset.xy_extent, [(0, 0), (239, 275)])

	def test_get_no_data_value(self):		def test_get_no_data_value(self):
	self.assertEqual(self.dataset.no_data_value, 0.0)		self.assertEqual(self.dataset.no_data_value, 0.0)

	def test_pixel_to_latlon(self):		def test_pixel_to_latlon(self):
	lat, lon = self.dataset.pixel_to_latlon(0,0)		lat, lon = self.dataset.pixel_to_latlon(0,0)
	self.assertAlmostEqual(lat, 90.0, 6)		self.assertAlmostEqual(lat, 69.9034915, 6)
	self.assertAlmostEqual(lon, 20.0, 6)		self.assertAlmostEqual(lon, -29.72166902, 6)

	def test_latlon_to_pixel(self):		def test_latlon_to_pixel(self):
	lat, lon = 69.90349154912009, -29.72166902463681		lat, lon = 69.90349154912009, -29.72166902463681
	@@ -126,10 +123,6 @@ class TestLambert(unittest.TestCase):
	sp = self.dataset.standard_parallels		sp = self.dataset.standard_parallels
	self.assertEqual(sp, [73.0, 42.0])		self.assertEqual(sp, [73.0, 42.0])

	def test_xy_extent(self):
	xy_extent = self.dataset.xy_extent
	self.assertEqual(xy_extent, [(-464400.0, -506970.0), (460530.0, -1571220.0)])


	class TestPolar(unittest.TestCase):		class TestPolar(unittest.TestCase):
	def setUp(self):		def setUp(self):
	@@ -143,15 +136,15 @@ class TestPolar(unittest.TestCase):
	self.assertEqual(self.dataset.unit_type, '')		self.assertEqual(self.dataset.unit_type, '')

	def test_get_xy_extent(self):		def test_get_xy_extent(self):
	self.assertEqual(self.dataset.xy_extent, [(-2129800.0, 2129800.0), (2129800.0, -2129800.0)])		self.assertEqual(self.dataset.xy_extent, [(0, 0), (920, 920)])

	def test_get_no_data_value(self):		def test_get_no_data_value(self):
	self.assertEqual(self.dataset.no_data_value, 0.0)		self.assertEqual(self.dataset.no_data_value, 0.0)

	def test_pixel_to_latlon(self):		def test_pixel_to_latlon(self):
	lat, lon = self.dataset.pixel_to_latlon(0,0)		lat, lon = self.dataset.pixel_to_latlon(0,0)
	self.assertAlmostEqual(lat, 90, 6)		self.assertAlmostEqual(lat, 42.2574735, 6)
	self.assertAlmostEqual(lon, 0.0, 6)		self.assertAlmostEqual(lon, -135.0, 6)

	def test_latlon_to_pixel(self):		def test_latlon_to_pixel(self):
	lat, lon = 42.2574735013, -135.0		lat, lon = 42.2574735013, -135.0
	@@ -159,10 +152,6 @@ class TestPolar(unittest.TestCase):
	self.assertAlmostEqual(pixel[0], 0.0, 6)		self.assertAlmostEqual(pixel[0], 0.0, 6)
	self.assertAlmostEqual(pixel[1], 0.0, 6)		self.assertAlmostEqual(pixel[1], 0.0, 6)

	def test_xy_extent(self):
	xy_extent = self.dataset.xy_extent
	self.assertEqual(xy_extent, [(-2129800.0, 2129800.0), (2129800.0, -2129800.0)])

	class TestWriter(unittest.TestCase):		class TestWriter(unittest.TestCase):
	def setUp(self):		def setUp(self):
	self.arr = np.random.random((100,100))		self.arr = np.random.random((100,100))

functional_tests/test_two_image.py

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -79,10 +79,6 @@ class TestTwoImageMatching(unittest.TestCase):
	# Step: Compute the homographies and apply RANSAC		# Step: Compute the homographies and apply RANSAC
	cg.compute_homographies(clean_keys=['symmetry', 'ratio'])		cg.compute_homographies(clean_keys=['symmetry', 'ratio'])

	# Step: Compute the overlap ratio and coverage ratio
	for s, d, edge in cg.edges_iter(data=True):
	edge.coverage_ratio(clean_keys=['symmetry', 'ratio'])

	# Apply AMNS		# Apply AMNS
	cg.suppress(k=30, suppression_func=error)		cg.suppress(k=30, suppression_func=error)