예제 #1
0
    def test_get_geolocation_grids(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.get_geolocation_grids()

        self.assertEqual(type(lon), np.ndarray)
        self.assertEqual(type(lat), np.ndarray)
        self.assertEqual(lat.shape, (500, 500))
예제 #2
0
    def test_get_geolocation_grids(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.get_geolocation_grids()

        self.assertEqual(type(lon), np.ndarray)
        self.assertEqual(type(lat), np.ndarray)
        self.assertEqual(lat.shape, (500, 500))
예제 #3
0
    def test_reproject_domain_if_tps_is_given(self):
        n = Nansat(self.test_file_gcps,
                   log_level=40,
                   mapper=self.default_mapper)
        d = Domain(4326, "-te 27 70 30 72 -ts 500 500")
        n.reproject(d, tps=False)
        tmpfilename = os.path.join(self.tmp_data_path,
                                   'nansat_reproject_domain.png')
        n.write_figure(tmpfilename, 2, clim='hist')

        self.assertEqual(n.shape(), (500, 500))
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertTrue(n.has_band('swathmask'))

        n = Nansat(self.test_file_gcps,
                   log_level=40,
                   mapper=self.default_mapper)
        d = Domain(4326, "-te 27 70 30 72 -ts 500 500")
        n.reproject(d, tps=True)
        tmpfilename = os.path.join(self.tmp_data_path,
                                   'nansat_reproject_domain.png')
        n.write_figure(tmpfilename, 2, clim='hist')

        self.assertEqual(n.shape(), (500, 500))
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertTrue(n.has_band('swathmask'))
예제 #4
0
def get_drift_vectors(n1, x1, y1, n2, x2, y2, nsr=NSR(), **kwargs):
    ''' Find ice drift speed m/s
    Parameters
    ----------
        n1 : First Nansat object
        x1 : 1D vector - X coordinates of keypoints on image 1
        y1 : 1D vector - Y coordinates of keypoints on image 1
        n2 : Second Nansat object
        x1 : 1D vector - X coordinates of keypoints on image 2
        y1 : 1D vector - Y coordinates of keypoints on image 2
        nsr: Nansat.NSR(), projection that defines the grid
    Returns
    -------
        u : 1D vector - eastward ice drift speed
        v : 1D vector - northward ice drift speed
        lon1 : 1D vector - longitudes of source points
        lat1 : 1D vector - latitudes of source points
        lon2 : 1D vector - longitudes of destination points
        lat2 : 1D vector - latitudes of destination points
    '''
    # convert x,y to lon, lat
    lon1, lat1 = n1.transform_points(x1, y1)
    lon2, lat2 = n2.transform_points(x2, y2)

    # create domain that converts lon/lat to units of the projection
    d = Domain(nsr, '-te -10 -10 10 10 -tr 1 1')

    # find displacement in needed units
    x1, y1 = d.transform_points(lon1, lat1, 1)
    x2, y2 = d.transform_points(lon2, lat2, 1)

    return x2 - x1, y1 - y2, lon1, lat1, lon2, lat2
예제 #5
0
    def test_reproject_GCPs(self):
        ds = gdal.Open(self.test_file)
        d = Domain(ds=ds)
        d.reproject_GCPs('+proj=stere +datum=WGS84 +ellps=WGS84 +lat_0=75 +lon_0=10 +no_defs')
        gcp = d.vrt.dataset.GetGCPs()[0]

        self.assertTrue(gcp.GCPX > 636161)
        self.assertTrue(gcp.GCPY < -288344)
예제 #6
0
    def test_write_map(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        tmpfilename = os.path.join(ntd.tmp_data_path, 'domain_write_map.png')
        d.write_map(tmpfilename)

        self.assertTrue(os.path.exists(tmpfilename))
        i = Image.open(tmpfilename)
        i.verify()
        self.assertEqual(i.info['dpi'], (50, 50))
예제 #7
0
    def test_get_border(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.get_border()

        self.assertEqual(type(lon), np.ndarray)
        self.assertEqual(type(lat), np.ndarray)
        self.assertEqual(len(lat), 44)
        self.assertEqual(lat[0], lat[-1])
        self.assertEqual(lon[0], lon[-1])
예제 #8
0
    def test_write_map(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        tmpfilename = os.path.join(ntd.tmp_data_path, 'domain_write_map.png')
        d.write_map(tmpfilename)

        self.assertTrue(os.path.exists(tmpfilename))
        i = Image.open(tmpfilename)
        i.verify()
        self.assertEqual(i.info['dpi'], (50, 50))
예제 #9
0
    def test_get_border(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.get_border()

        self.assertEqual(type(lon), np.ndarray)
        self.assertEqual(type(lat), np.ndarray)
        self.assertEqual(len(lat), 44)
        self.assertEqual(lat[0], lat[-1])
        self.assertEqual(lon[0], lon[-1])
예제 #10
0
    def test_reproject_GCPs(self):
        ds = gdal.Open(self.test_file)
        d = Domain(ds=ds)
        d.reproject_GCPs(
            '+proj=stere +datum=WGS84 +ellps=WGS84 +lat_0=75 +lon_0=10 +no_defs'
        )
        gcp = d.vrt.dataset.GetGCPs()[0]

        self.assertTrue(gcp.GCPX > 636161)
        self.assertTrue(gcp.GCPY < -288344)
예제 #11
0
    def test_integrated(self):
        ''' Shall use all developed functions for feature tracking'''
        lon1pm, lat1pm = np.meshgrid(np.linspace(-3, 2, 50),
                                     np.linspace(86.4, 86.8, 50))

        sid = SeaIceDrift(self.testFiles[0], self.testFiles[1])
        uft, vft, lon1ft, lat1ft, lon2ft, lat2ft = sid.get_drift_FT()
        upm, vpm, apm, rpm, hpm, lon2pm, lat2pm = sid.get_drift_PM(
            lon1pm, lat1pm, lon1ft, lat1ft, lon2ft, lat2ft)

        lon1, lat1 = sid.n1.get_border()
        lon2, lat2 = sid.n2.get_border()
        sid.n1.reproject(Domain(NSR().wkt, '-te -3 86.4 2 86.8 -ts 500 500'))
        s01 = sid.n1['sigma0_HV']
        sid.n2.reproject(Domain(NSR().wkt, '-te -3 86.4 2 86.8 -ts 500 500'))
        s02 = sid.n2['sigma0_HV']

        plt.imshow(s01, extent=[-3, 2, 86.4, 86.8], cmap='gray', aspect=12)
        plt.quiver(lon1ft,
                   lat1ft,
                   uft,
                   vft,
                   color='r',
                   angles='xy',
                   scale_units='xy',
                   scale=0.5)
        plt.plot(lon2, lat2, '.-r')
        plt.xlim([-3, 2])
        plt.ylim([86.4, 86.8])
        plt.savefig('sea_ice_drift_tests_%s_img1_ft.png' %
                    inspect.currentframe().f_code.co_name,
                    dpi=150,
                    bbox_inches='tight',
                    pad_inches=0)
        plt.close('all')

        plt.imshow(s02, extent=[-3, 2, 86.4, 86.8], cmap='gray', aspect=12)
        gpi = rpm > 0.4
        plt.quiver(lon1pm[gpi],
                   lat1pm[gpi],
                   upm[gpi],
                   vpm[gpi],
                   rpm[gpi] * hpm[gpi],
                   angles='xy',
                   scale_units='xy',
                   scale=0.5)
        plt.plot(lon1, lat1, '.-r')
        plt.xlim([-3, 2])
        plt.ylim([86.4, 86.8])
        plt.savefig('sea_ice_drift_tests_%s_img2_pm.png' %
                    inspect.currentframe().f_code.co_name,
                    dpi=150,
                    bbox_inches='tight',
                    pad_inches=0)
        plt.close('all')
예제 #12
0
    def test_write_map_labels(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        tmpfilename = os.path.join(ntd.tmp_data_path,
                                   'domain_write_map_labels.png')
        d.write_map(tmpfilename,
                    merLabels=[False, False, False, True],
                    parLabels=[True, False, False, False])

        self.assertTrue(os.path.exists(tmpfilename))
        i = Image.open(tmpfilename)
        i.verify()
예제 #13
0
    def test_write_map_labels(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        tmpfilename = os.path.join(ntd.tmp_data_path,
                                   'domain_write_map_labels.png')
        d.write_map(tmpfilename,
                    merLabels=[False, False, False, True],
                    parLabels=[True, False, False, False])

        self.assertTrue(os.path.exists(tmpfilename))
        i = Image.open(tmpfilename)
        i.verify()
예제 #14
0
 def test_overlaps_contains(self):
     Bergen = Domain(4326, "-te 5 60 6 61 -ts 500 500")
     WestCoast = Domain(4326, "-te 1 58 6 64 -ts 500 500")
     Norway = Domain(4326, "-te 3 55 30 72 -ts 500 500")
     Paris = Domain(4326, "-te 2 48 3 49 -ts 500 500")
     self.assertTrue(Bergen.overlaps(Norway))
     self.assertTrue(Norway.contains(Bergen))
     self.assertFalse(Bergen.contains(Norway))
     self.assertTrue(Norway.overlaps(WestCoast))
     self.assertFalse(Norway.contains(WestCoast))
     self.assertFalse(Paris.overlaps(Norway))
     self.assertFalse(Paris.contains(Norway))
예제 #15
0
    def test_export2thredds_longlat_list(self):
        d = Domain("+proj=latlong +datum=WGS84 +ellps=WGS84 +no_defs",
                   "-te 27 70 31 72 -ts 200 200")
        n = Nansat(domain=d)
        n.add_band(np.ones(d.shape(), np.float32),
                   parameters={'name': 'L_469'})
        n.set_metadata('time_coverage_start', '2016-01-19')

        tmpfilename = os.path.join(ntd.tmp_data_path,
                                   'nansat_export2thredds_longlat.nc')
        n.export2thredds(tmpfilename, ['L_469'])
        ncI = netcdf_file(tmpfilename, 'r')
        ncIVar = ncI.variables['L_469']
        self.assertTrue(ncIVar.grid_mapping in ncI.variables.keys())
예제 #16
0
    def test_export2thredds_longlat_list(self):
        d = Domain("+proj=latlong +datum=WGS84 +ellps=WGS84 +no_defs",
                   "-te 27 70 31 72 -ts 200 200")
        n = Nansat(domain=d)
        n.add_band(np.ones(d.shape(), np.float32),
                   parameters={'name': 'L_469'})
        n.set_metadata('time_coverage_start', '2016-01-19')

        tmpfilename = os.path.join(ntd.tmp_data_path,
                                   'nansat_export2thredds_longlat.nc')
        n.export2thredds(tmpfilename, ['L_469'])
        ncI = netcdf_file(tmpfilename, 'r')
        ncIVar = ncI.variables['L_469']
        self.assertTrue(ncIVar.grid_mapping in ncI.variables.keys())
예제 #17
0
def get_displacement_km(n1, x1, y1, n2, x2, y2, ll2km='domain'):
    ''' Find displacement in kilometers using Domain'''
    lon1, lat1 = n1.transform_points(x1, y1)
    lon2, lat2 = n2.transform_points(x2, y2)

    d = Domain(
        '+proj=stere +lon_0=%f +lat_0=%f +no_defs' %
        (lon1.mean(), lat1.mean()),
        '-te -100000 -100000 100000 100000 -tr 1000 1000')

    x1d, y1d = d.transform_points(lon1, lat1, 1)
    x2d, y2d = d.transform_points(lon2, lat2, 1)

    return x2d - x1d, y1d - y2d
예제 #18
0
    def test_export2thredds_longlat_dict(self):
        d = Domain("+proj=latlong +datum=WGS84 +ellps=WGS84 +no_defs",
                   "-te 27 70 31 72 -ts 200 200")
        n = Nansat.from_domain(d)
        n.add_band(np.ones(d.shape(), np.float32),
                   parameters={'name': 'L_469'})
        n.set_metadata('time_coverage_start', '2016-01-19')

        tmpfilename = os.path.join(self.tmp_data_path,
                                   'nansat_export2thredds_longlat.nc')
        n.export2thredds(tmpfilename, {'L_469': {'type': '>i1'}})
        ncI = Dataset(tmpfilename, 'r')
        ncIVar = ncI.variables['L_469']
        self.assertTrue(ncIVar.grid_mapping in ncI.variables.keys())
        self.assertEqual(ncIVar[:].dtype, np.int8)
예제 #19
0
    def test_export2thredds_longlat_dict(self):
        d = Domain("+proj=latlong +datum=WGS84 +ellps=WGS84 +no_defs",
                   "-te 27 70 31 72 -ts 200 200")
        n = Nansat.from_domain(d)
        n.add_band(np.ones(d.shape(), np.float32),
                   parameters={'name': 'L_469'})
        n.set_metadata('time_coverage_start', '2016-01-19')

        tmpfilename = os.path.join(self.tmp_data_path,
                                   'nansat_export2thredds_longlat.nc')
        n.export2thredds(tmpfilename, {'L_469': {'type': '>i1'}})
        ncI = Dataset(tmpfilename, 'r')
        ncIVar = ncI.variables['L_469']
        self.assertTrue(ncIVar.grid_mapping in ncI.variables.keys())
        self.assertEqual(ncIVar[:].dtype, np.int8)
예제 #20
0
 def test_get_item_inf_expressions(self):
     ''' inf should be replaced with nan '''
     d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
     n = Nansat(domain=d, logLevel=40)
     arr = np.empty((500, 500))
     n.add_band(arr, {'expression': 'np.array([0,1,2,3,np.inf,5,6,7])'})
     self.assertIsInstance(n[1], np.ndarray)
     self.assertTrue(np.isnan(n[1][4]))
예제 #21
0
    def test_integrated(self, mock_get_invalid_mask):
        ''' Shall use all developed functions for feature tracking'''

        invalid_mask =  np.zeros((500,500)).astype(bool)
        invalid_mask[:100,:100] = True
        mock_get_invalid_mask.return_value = invalid_mask

        sid = SeaIceDrift(self.testFiles[0], self.testFiles[1])

        lon1b, lat1b = sid.n1.get_border()
        lon1pm, lat1pm = np.meshgrid(np.linspace(lon1b.min(), lon1b.max(), 50),
                             np.linspace(lat1b.min(), lat1b.max(), 50))
        uft, vft, lon1ft, lat1ft, lon2ft, lat2ft = sid.get_drift_FT()
        upm, vpm, apm, rpm, hpm, lon2pm, lat2pm = sid.get_drift_PM(
                                            lon1pm, lat1pm,
                                            lon1ft, lat1ft,
                                            lon2ft, lat2ft)

        lon1, lat1 = sid.n1.get_border()
        lon2, lat2 = sid.n2.get_border()
        ext_str = '-te %s %s %s %s -ts 500 500' % (lon1b.min(), lat1b.min(), lon1b.max(), lat1b.max())
        sid.n1.reproject(Domain(NSR().wkt, ext_str))
        s01 = sid.n1['sigma0_HV']
        sid.n2.reproject(Domain(NSR().wkt, ext_str))
        s02 = sid.n2['sigma0_HV']
        extent=[lon1b.min(), lon1b.max(), lat1b.min(), lat1b.max()]
        plt.imshow(s01, extent=extent, cmap='gray', aspect=10)
        plt.quiver(lon1ft, lat1ft, uft, vft, color='r',
                   angles='xy', scale_units='xy', scale=0.2)
        plt.plot(lon2, lat2, '.-r')
        plt.xlim([lon1b.min(), lon1b.max()])
        plt.ylim([lat1b.min(), lat1b.max()])
        plt.savefig('sea_ice_drift_tests_%s_img1_ft.png' % inspect.currentframe().f_code.co_name,
                    dpi=150, bbox_inches='tight', pad_inches=0)
        plt.close('all')

        plt.imshow(s02, extent=extent, cmap='gray', aspect=10)
        gpi = hpm*rpm > 4
        plt.quiver(lon1pm[gpi], lat1pm[gpi], upm[gpi], vpm[gpi], rpm[gpi]*hpm[gpi],
                   angles='xy', scale_units='xy', scale=0.2)
        plt.plot(lon1, lat1, '.-r')
        plt.xlim([lon1b.min(), lon1b.max()])
        plt.ylim([lat1b.min(), lat1b.max()])
        plt.savefig('sea_ice_drift_tests_%s_img2_pm.png' % inspect.currentframe().f_code.co_name,
                    dpi=150, bbox_inches='tight', pad_inches=0)
        plt.close('all')
예제 #22
0
    def test_reproject_pure_geolocation(self):
        n0 = Nansat(self.test_file_gcps)
        b0 = n0[1]
        lon0, lat0 = n0.get_geolocation_grids()
        d1 = Domain.from_lonlat(lon=lon0, lat=lat0)
        d2 = Domain.from_lonlat(lon=lon0, lat=lat0, add_gcps=False)
        d3 = Domain(NSR().wkt, '-te 27 70 31 72 -ts 500 500')

        n1 = Nansat.from_domain(d1, b0)
        n2 = Nansat.from_domain(d2, b0)

        n1.reproject(d3)
        n2.reproject(d3)

        b1 = n1[1]
        b2 = n2[1]
        self.assertTrue(np.allclose(b1, b2))
예제 #23
0
    def setUp(self):
        self.test_file_gcps = os.path.join(ntd.test_data_path, 'gcps.tif')
        self.test_file_stere = os.path.join(ntd.test_data_path, 'stere.tif')
        self.test_file_complex = os.path.join(ntd.test_data_path, 'complex.nc')
        self.domain = Domain(4326, '-lle 27 70 31 72 -ts 700 650')
        plt.switch_backend('Agg')

        if not os.path.exists(self.test_file_gcps):
            raise ValueError('No test data available')
예제 #24
0
 def test_get_item_inf_expressions(self):
     """ inf should be replaced with nan """
     self.mock_pti['get_wkv_variable'].return_value=dict(short_name='newband')
     d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
     n = Nansat.from_domain(d, log_level=40)
     arr = np.empty((500, 500))
     n.add_band(arr, {'expression': 'np.array([0,1,2,3,np.inf,5,6,7])'})
     self.assertIsInstance(n[1], np.ndarray)
     self.assertTrue(np.isnan(n[1][4]))
예제 #25
0
 def test_get_item_basic_expressions(self):
     """ Testing get_item with some basic expressions """
     self.mock_pti['get_wkv_variable'].return_value=dict(short_name='newband')
     d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
     n = Nansat.from_domain(d, np.zeros((500, 500)), {'expression': 'np.ones((500, 500))'})
     self.assertIsInstance(n[1], np.ndarray)
     self.assertEqual(n[1].shape, (500, 500))
     band1 = n[1]
     self.assertTrue(np.allclose(band1, np.ones((500, 500))))
예제 #26
0
    def test_reproject_domain(self):
        n = Nansat(self.test_file_gcps, logLevel=40)
        d = Domain(4326, "-te 27 70 30 72 -ts 500 500")
        n.reproject(d)
        tmpfilename = os.path.join(ntd.tmp_data_path,
                                   'nansat_reproject_domain.png')
        n.write_figure(tmpfilename, 2, clim='hist')

        self.assertEqual(n.shape(), (500, 500))
        self.assertEqual(type(n[1]), np.ndarray)
예제 #27
0
    def test_reproject_no_addmask(self):
        ''' Should not add swath mask and return 0 in areas out of swath '''
        n = Nansat(self.test_file_complex, logLevel=40)
        d = Domain(4326, '-te -92.08 26.85 -92.00 26.91 -ts 200 200')
        n.reproject(d, addmask=False)
        b = n[1]

        self.assertTrue(not n.has_band('swathmask'))
        self.assertTrue(np.isfinite(b[0, 0]))
        self.assertTrue(np.isfinite(b[100, 100]))
예제 #28
0
    def test_reproject_domain_if_source_and_destination_domain_span_entire_lons(self, mock_Nansat):
        n = Nansat(self.test_file_arctic, log_level=40, mapper=self.default_mapper)
        d = Domain(4326, "-te -180 180 60 90 -ts 500 500")
        n.reproject(d)
        tmpfilename = os.path.join(self.tmp_data_path, 'nansat_reproject_domain.png')
        n.write_figure(tmpfilename, 2, clim='hist')

        self.assertEqual(n.shape(), (500, 500))
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertTrue(n.has_band('swathmask'))
예제 #29
0
    def test_add_band(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        arr = np.random.randn(500, 500)
        n = Nansat.from_domain(d, log_level=40)
        n.add_band(arr, {'name': 'band1'})

        self.assertEqual(type(n), Nansat)
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertEqual(n.get_metadata('name', 1), 'band1')
        self.assertEqual(n[1].shape, (500, 500))
예제 #30
0
    def test_add_bands_no_parameter(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        arr = np.random.randn(500, 500)

        n = Nansat.from_domain(d, log_level=40)
        n.add_bands([arr, arr])

        self.assertEqual(type(n), Nansat)
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertEqual(type(n[2]), np.ndarray)
예제 #31
0
    def test_reproject_of_complex(self):
        """ Should return np.nan in areas out of swath """
        n = Nansat(self.test_file_complex, log_level=40, mapper=self.default_mapper)
        d = Domain(4326, '-te -92.08 26.85 -92.00 26.91 -ts 200 200')
        n.reproject(d)
        b = n[1]

        self.assertTrue(n.has_band('swathmask'))
        self.assertTrue(np.isnan(b[0, 0]))
        self.assertTrue(np.isfinite(b[100, 100]))
예제 #32
0
    def test_reproject_no_addmask(self):
        """ Should not add swath mask and return 0 in areas out of swath """
        n = Nansat(self.test_file_gcps, log_level=40, mapper=self.default_mapper)
        d = Domain(4326, '-te -92.08 26.85 -92.00 26.91 -ts 200 200')
        n.reproject(d, addmask=False)
        b = n[1]

        self.assertTrue(not n.has_band('swathmask'))
        self.assertTrue(np.isfinite(b[0, 0]))
        self.assertTrue(np.isfinite(b[100, 100]))
예제 #33
0
    def test_add_subvrts_only_to_one_nansat(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        arr = np.random.randn(500, 500)

        n1 = Nansat.from_domain(d, log_level=40)
        n2 = Nansat.from_domain(d, log_level=40)
        n1.add_band(arr, {'name': 'band1'})

        self.assertEqual(type(n1.vrt.band_vrts), dict)
        self.assertTrue(len(n1.vrt.band_vrts) > 0)
        self.assertEqual(n2.vrt.band_vrts, {})
예제 #34
0
    def test_init_domain_array(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        n = Nansat(domain=d,
                   array=np.random.randn(500, 500),
                   parameters={'name': 'band1'},
                   logLevel=40)

        self.assertEqual(type(n), Nansat)
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertEqual(n.get_metadata('name', 1), 'band1')
        self.assertEqual(n[1].shape, (500, 500))
예제 #35
0
    def test_add_bands(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        arr = np.random.randn(500, 500)

        n = Nansat(domain=d, logLevel=40)
        n.add_bands([arr, arr], [{'name': 'band1'}, {'name': 'band2'}])

        self.assertEqual(type(n), Nansat)
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertEqual(type(n[2]), np.ndarray)
        self.assertEqual(n.get_metadata('name', 1), 'band1')
        self.assertEqual(n.get_metadata('name', 2), 'band2')
예제 #36
0
    def test_from_domain_array(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        n = Nansat.from_domain(d, np.random.randn(500, 500), {'name': 'band1'})

        self.assertEqual(type(n), Nansat)
        self.assertEqual(type(n[1]), np.ndarray)
        self.assertEqual(n.get_metadata('name', 1), 'band1')
        self.assertEqual(n[1].shape, (500, 500))
        self.assertEqual(n.filename, '')
        self.assertIsInstance(n.logger, logging.Logger)
        self.assertEqual(n.name, '')
        self.assertEqual(n.path, '')
예제 #37
0
 def test_get_item_basic_expressions(self):
     ''' Testing get_item with some basic expressions '''
     d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
     n = Nansat(domain=d, logLevel=40)
     arr = np.empty((500, 500))
     n.add_band(arr, {'expression': '1+1'})
     n.add_band(arr, {'expression': 'np.random.randn(500, 500)'})
     self.assertIsInstance(n[1], int)
     self.assertIsInstance(n[2], np.ndarray)
     self.assertEqual(n[1], 2)
     self.assertEqual(len(n[2]), 500)
     self.assertEqual(len(n[2][0]), 500)
예제 #38
0
    def test_add_bands(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        arr = np.random.randn(500, 500)

        n = Nansat.from_domain(d, log_level=40)
        n.add_bands([arr, arr], [{'name': 'band1'}, {'name': 'band2'}])

        self.assertIsInstance(n, Nansat)
        self.assertEqual(n.vrt.vrt.vrt, None)
        self.assertIsInstance(n[1], np.ndarray)
        self.assertIsInstance(n[2], np.ndarray)
        self.assertEqual(n.get_metadata('name', 1), 'band1')
        self.assertEqual(n.get_metadata('name', 2), 'band2')
예제 #39
0
    def test_get_pixelsize_meters(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        x, y = d.get_pixelsize_meters()

        self.assertTrue(x - 444 < 1)
        self.assertTrue(y - 723 < 1)
예제 #40
0
    def test_transform_points(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.transform_points([1, 2, 3], [1, 2, 3])

        self.assertEqual(type(lon), np.ndarray)
        self.assertEqual(type(lat), np.ndarray)
예제 #41
0
    def test_write_kml(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        tmpfilename = os.path.join(ntd.tmp_data_path, 'domain_write_kml.kml')
        d.write_kml(kmlFileName=tmpfilename)

        self.assertTrue(os.path.exists(tmpfilename))
예제 #42
0
    def test_init_from_lonlat(self):
        lat, lon = np.mgrid[-90:90:0.5, -180:180:0.5]
        d = Domain(lon=lon, lat=lat)

        self.assertEqual(type(d), Domain)
        self.assertEqual(d.shape(), lat.shape)
예제 #43
0
    def test_shape(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        shape = d.shape()

        self.assertEqual(shape, (500, 500))
예제 #44
0
print 'Output file:', oFileName, '\n'

''' Domain class is a container for geographical reference of a raster

A Domain object describes all attributes of geographical
reference of a raster:
    width and height, pixel size,
    relation between pixel/line coordinates and geographical coordinates,
    type of data projection (e.g. geographical or stereographic)

'''

# Create Domain object. It describes the desired grid of reprojected image:
# projection, resolution, size, etc. In this case it is geographic projection;
# -10 - 30 E, 50 - 70 W; 2000 x 2000 pixels
d = Domain("+proj=latlong +datum=WGS84 +ellps=WGS84 +no_defs",
           "-te 25 70 35 72 -ts 2000 2000")
d = Domain(4326, "-te 25 70 35 72 -ts 2000 2000")
d.write_map(oFileName + '01_latlong_map.png')
print 'Latlong Domain:', d, '\n'

# get shape
print 'shape:', d.shape(), '\n'

# Generate two vectors with values of lat/lon for the border of domain
lonVec, latVec = d.get_border()
print 'lonVec :', lonVec, '\n'
print 'latVec :', latVec, '\n'

# Get upwards azimuth direction of domain.
bearing_center = d.upwards_azimuth_direction()
print 'bearing_center :', bearing_center, '\n'
예제 #45
0
    def test_azimuth_y(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        au = d.azimuth_y()

        self.assertEqual(np.round(au[0, 0]), 0)
        self.assertEqual(np.round(au[10, 10]), 0)
예제 #46
0
    def test_transform_points_inverse(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        x, y = d.transform_points([25, 26, 27], [70, 71, 72], 1)

        self.assertTrue(all(np.round(x) == [0, 50, 100]))
        self.assertTrue(all(np.round(y) == [500, 250, 0]))
예제 #47
0
    def test_get_border_wkt(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        bwkt = d.get_border_wkt()

        self.assertEqual(type(bwkt), str)
        self.assertTrue('POLYGON' in bwkt)
예제 #48
0
    def test_get_border_geometry(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        geom = d.get_border_geometry()

        self.assertEqual(type(geom), ogr.Geometry)
예제 #49
0
    def test_get_corners(self):
        d = Domain(4326, "-te 25 70 35 72 -ts 500 500")
        lon, lat = d.get_corners()

        self.assertTrue(all(lon - [25., 25., 35., 35.] < 0.01))
        self.assertTrue(all(lat - [72., 70., 72., 70.] < 0.01))