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	Diff line number	Diff line
		@@ -151,6 +151,8 @@ class GeoDataset(object):
		if self.dataset is None:
		raise IOError('File not found :', file_name)



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

		@@ -206,26 +208,6 @@ class GeoDataset(object):
		self._gcs = self.spatial_reference.CloneGeogCS()
		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
		def metadata(self):
		if not hasattr(self, '_metadata'):
		@@ -255,54 +237,58 @@ class GeoDataset(object):
		return self._footprint

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

		def latlon_corners(self):
		if not getattr(self, '_latlon_corners', None):
		pixel_corners = self.xy_corners
		gt = self.geotransform
		x = [0, self.dataset.RasterXSize]
		y = [0, self.dataset.RasterYSize]

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

		for x, y in pixel_corners:
		x, y = self.pixel_to_latlon(x, y)
		self._latlon_corners.append((x, y))
		return self._latlon_corners

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

		maxx = minx + geotransform[1] * self.dataset.RasterXSize
		maxy = miny + geotransform[5] * self.dataset.RasterYSize
		@property
		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
		def pixel_polygon(self):
		"""
		A bounding polygon in pixel space
		def xy_extent(self):
		return [(0, 0),
		(self.dataset.RasterXSize, self.dataset.RasterYSize)]

		Returns
		-------
		: object
		A PySAL Polygon object
		"""
		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
		def proj_extent(self):
		# The extent in projected space
		raise NotImplementedError

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

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

autocnet/fileio/tests/test_io_gdal.py

+11 −22

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

		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):
		self.assertEqual(self.dataset.no_data_value, 0.0)

		def test_pixel_to_latlon(self):
		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)

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

		def test_xy_extent(self):
		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):
		xy_corners = self.dataset.xy_corners
		self.assertEqual(xy_corners, [(0.0, 3921610.0), (0.0, -3921610.0),
		(10667520.0, -3921610.0), (10667520.0, 3921610.0)])
		self.assertEqual(xy_corners, [(0, 0), (0, 1694), (2304, 1694), (2304, 0)])

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

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

		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):
		self.assertEqual(self.dataset.no_data_value, 0.0)

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

		def test_latlon_to_pixel(self):
		lat, lon = 69.90349154912009, -29.72166902463681
		@@ -126,10 +123,6 @@ class TestLambert(unittest.TestCase):
		sp = self.dataset.standard_parallels
		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):
		def setUp(self):
		@@ -143,15 +136,15 @@ class TestPolar(unittest.TestCase):
		self.assertEqual(self.dataset.unit_type, '')

		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):
		self.assertEqual(self.dataset.no_data_value, 0.0)

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

		def test_latlon_to_pixel(self):
		lat, lon = 42.2574735013, -135.0
		@@ -159,10 +152,6 @@ class TestPolar(unittest.TestCase):
		self.assertAlmostEqual(pixel[0], 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):
		def setUp(self):
		self.arr = np.random.random((100,100))

functional_tests/test_two_image.py

+0 −4

Original line number	Diff line number	Diff line
		@@ -79,10 +79,6 @@ class TestTwoImageMatching(unittest.TestCase):
		# Step: Compute the homographies and apply RANSAC
		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
		cg.suppress(k=30, suppression_func=error)