def test_from_filenames(self): lon, lat = np.meshgrid(np.linspace(0,5,10), np.linspace(10,20,30)) x_vrt = VRT.from_array(lon) y_vrt = VRT.from_array(lat) g = Geolocation.from_filenames(x_vrt.filename, y_vrt.filename) self.assertIsInstance(g, Geolocation) self.assertEqual(g.data['X_DATASET'], x_vrt.filename) self.assertEqual(g.data['Y_DATASET'], y_vrt.filename) self.assertEqual(g.data['LINE_OFFSET'], '0') self.assertEqual(g.data['LINE_STEP'], '1') self.assertEqual(g.data['PIXEL_OFFSET'], '0') self.assertEqual(g.data['PIXEL_STEP'], '1')
def test_init(self): lon, lat = np.meshgrid(np.linspace(0, 5, 10), np.linspace(10, 20, 30)) x_vrt = VRT.from_array(lon) y_vrt = VRT.from_array(lat) ga = Geolocation(x_vrt, y_vrt) self.assertIsInstance(ga, Geolocation) self.assertEqual(ga.data['X_DATASET'], x_vrt.filename) self.assertEqual(ga.data['Y_DATASET'], y_vrt.filename) self.assertEqual(ga.data['LINE_OFFSET'], '0') self.assertEqual(ga.data['LINE_STEP'], '1') self.assertEqual(ga.data['PIXEL_OFFSET'], '0') self.assertEqual(ga.data['PIXEL_STEP'], '1') srs = osr.SpatialReference() status = srs.ImportFromWkt(ga.data['SRS']) self.assertEqual(status, 0) self.assertEqual(srs.ExportToProj4().strip(), '+proj=longlat +datum=WGS84 +no_defs') self.assertEqual(ga.data['X_BAND'], '1') self.assertEqual(ga.data['Y_BAND'], '1') self.assertEqual(ga.x_vrt, x_vrt) self.assertEqual(ga.y_vrt, y_vrt)
def add_geolocation_from_ads(self, gdalDataset, zoomSize=500, step=1): """ Add geolocation domain metadata to the dataset Get VRTs with zoomed arrays of lon and lat Create geolocation object and add to the metadata Parameters ---------- gdalDataset: GDAL Dataset input dataset zoomSize: int, optional, 500 size, to which the ADS array will be zoomed using scipy array of this size will be stored in memory step: int step of pixel and line in GeolocationArrays. lat/lon grids are generated at that step Modifies -------- Adds Geolocation Array metadata """ # get VRTs with lon and lat xyVRTs = self.get_ads_vrts(gdalDataset, self.lonlatNames, zoomSize, step) # Add geolocation domain metadata to the dataset self._add_geolocation( Geolocation(x_vrt=xyVRTs[0], y_vrt=xyVRTs[1], x_band=1, y_band=1, srs=gdalDataset.GetGCPProjection(), line_offset=0, line_step=step, pixel_offset=0, pixel_step=step))
def __init__(self, filename, gdalDataset, gdalMetadata, **kwargs): ######################################## # Read metadata from binary file ######################################## try: fp = open(filename, 'rb') except IOError: raise WrongMapperError fp.seek(24) try: satID = int(struct.unpack('<l', fp.read(4))[0]) except: raise WrongMapperError ################## # Read time ################## fp.seek(44) year = int(struct.unpack('<l', fp.read(4))[0]) dayofyear = int(struct.unpack('<l', fp.read(4))[0]) millisecondsOfDay = int(struct.unpack('<l', fp.read(4))[0]) try: time = (datetime.datetime(year, 1, 1) + datetime.timedelta( dayofyear - 1, milliseconds=millisecondsOfDay)) except: raise WrongMapperError fp.seek(72) numScanLines = int(struct.unpack('<l', fp.read(4))[0]) missingScanLines = int(struct.unpack('<l', fp.read(4))[0]) numCalibratedScanLines = int(struct.unpack('<l', fp.read(4))[0]) if missingScanLines != 0: print('WARNING: Missing scanlines: ' + str(missingScanLines)) fp.seek(88) dataFormatNum = int(struct.unpack('<l', fp.read(4))[0]) dataFormat = dataFormats[dataFormatNum] # Determine if we have channel 3A (daytime) or channel 3B (nighttime) def int2bitstring(s): return str(s) if s <= 1 else int2bitstring(s >> 1) + str(s & 1) fp.seek(headerLength + 20) scanlinebitFirstline = int(struct.unpack('<L', fp.read(4))[0]) fp.seek(headerLength + recordLength * (numCalibratedScanLines - 2) + 20) scanlinebitLastline = int(struct.unpack('<L', fp.read(4))[0]) if int2bitstring(scanlinebitFirstline)[-1] == '0': startsWith3A = True else: startsWith3A = False if int2bitstring(scanlinebitLastline)[-1] == '0': endsWith3A = True else: endsWith3A = False if startsWith3A != endsWith3A: print('############################################') print('WARNING: channel 3 switches ') print('between daytime and nighttime (3A <-> 3B)') print('###########################################') ########################### # Make Geolocation Arrays ########################### srcRasterYSize = numCalibratedScanLines # Making VRT with raw (unscaled) lon and lat # (smaller bands than full dataset) self.band_vrts = { 'RawGeolocVRT': VRT(srcRasterXSize=51, srcRasterYSize=srcRasterYSize) } RawGeolocMetaDict = [] for lonlatNo in range(1, 3): RawGeolocMetaDict.append({ 'src': { 'SourceFilename': filename, 'SourceBand': 0, 'SourceType': "RawRasterBand", 'DataType': gdal.GDT_Int32, 'ImageOffset': (headerLength + 676 + (lonlatNo - 1) * 4), 'PixelOffset': 8, 'LineOffset': recordLength, 'ByteOrder': 'LSB' }, 'dst': {} }) self.band_vrts['RawGeolocVRT'].create_bands(RawGeolocMetaDict) # Make derived GeolocVRT with scaled lon and lat self.band_vrts['GeolocVRT'] = VRT(srcRasterXSize=51, srcRasterYSize=srcRasterYSize) GeolocMetaDict = [] for lonlatNo in range(1, 3): GeolocMetaDict.append({ 'src': { 'SourceFilename': (self.band_vrts['RawGeolocVRT'].filename), 'SourceBand': lonlatNo, 'ScaleRatio': 0.0001, 'ScaleOffset': 0, 'DataType': gdal.GDT_Int32 }, 'dst': {} }) self.band_vrts['GeolocVRT'].create_bands(GeolocMetaDict) GeolocObject = Geolocation( x_vrt=self.band_vrts['GeolocVRT'], y_vrt=self.band_vrts['GeolocVRT'], x_band=2, y_band=1, # x = lon, y = lat line_offset=0, pixel_offset=25, line_step=1, pixel_step=40) ####################### # Initialize dataset ####################### # create empty VRT dataset with geolocation only # (from Geolocation Array) self._init_from_dataset_params( 2048, numCalibratedScanLines, (0, 1, 0, numCalibratedScanLines, 0, -1), GeolocObject.d['SRS']) self._add_geolocation(GeolocObject) ################## # Create bands ################## self.band_vrts['RawBandsVRT'] = VRT( srcRasterXSize=2048, srcRasterYSize=numCalibratedScanLines) RawMetaDict = [] metaDict = [] centralWavelengths = [0.63, 0.86, np.NaN, 10.8, 12.0] if startsWith3A: centralWavelengths[2] = 1.6 firstIRband = 4 else: centralWavelengths[2] = 3.7 firstIRband = 3 for bandNo in range(1, 6): RawMetaDict.append({ 'src': { 'SourceFilename': filename, 'SourceBand': 0, 'SourceType': "RawRasterBand", 'dataType': gdal.GDT_UInt16, 'ImageOffset': imageOffset + (bandNo - 1) * 2, 'PixelOffset': 10, 'LineOffset': recordLength, 'ByteOrder': 'LSB' }, 'dst': { 'dataType': gdal.GDT_UInt16 } }) if bandNo < firstIRband: wkv = 'albedo' minmax = '0 60' else: wkv = 'brightness_temperature' minmax = '290 210' metaDict.append({ 'src': { 'SourceFilename': (self.band_vrts['RawBandsVRT'].filename), 'SourceBand': bandNo, 'ScaleRatio': 0.01, 'ScaleOffset': 0, 'DataType': gdal.GDT_UInt16 }, 'dst': { 'originalFilename': filename, 'dataType': gdal.GDT_Float32, 'wkv': wkv, 'colormap': 'gray', 'wavelength': centralWavelengths[bandNo - 1], 'minmax': minmax } }) # Add temperature difference between ch3 and ch 4 as pixelfunction if not startsWith3A: # Only if ch3 is IR (nighttime) metaDict.append({ 'src': [{ 'SourceFilename': (self.band_vrts['RawBandsVRT'].filename), 'ScaleRatio': 0.01, 'ScaleOffset': 0, 'SourceBand': 4 }, { 'SourceFilename': (self.band_vrts['RawBandsVRT'].filename), 'ScaleRatio': 0.01, 'ScaleOffset': 0, 'SourceBand': 3 }], 'dst': { 'PixelFunctionType': 'diff', 'originalFilename': filename, 'dataType': gdal.GDT_Float32, 'name': 'ch4-ch3', 'short_name': 'ch4-ch3', 'long_name': 'AVHRR ch4 - ch3 temperature difference', 'colormap': 'gray', 'units': 'kelvin', 'minmax': '-3 3' } }) self.self.band_vrts['RawBandsVRT'].create_bands(RawMetaDict) self.create_bands(metaDict) globalMetadata = {} globalMetadata['satID'] = str(satID) globalMetadata['daytime'] = str(int(startsWith3A)) self.dataset.SetMetadata(globalMetadata) # Adding valid time to dataset self.dataset.SetMetadataItem('time_coverage_start', time.isoformat()) self.dataset.SetMetadataItem('time_coverage_end', time.isoformat()) return
def test_from_dataset(self): ds = gdal.Open(self.test_file) g = Geolocation.from_dataset(ds) self.assertIsInstance(g, Geolocation)
def __init__(self, inputFileName, gdalDataset, gdalMetadata, logLevel=30, rmMetadatas=['NETCDF_VARNAME', '_Unsigned', 'ScaleRatio', 'ScaleOffset', 'dods_variable'], **kwargs): # Remove 'NC_GLOBAL#' and 'GDAL_' and 'NANSAT_' # from keys in gdalDataset tmpGdalMetadata = {} geoMetadata = {} origin_is_nansat = False if not gdalMetadata: raise WrongMapperError for key in gdalMetadata.keys(): newKey = key.replace('NC_GLOBAL#', '').replace('GDAL_', '') if 'NANSAT_' in newKey: geoMetadata[newKey.replace('NANSAT_', '')] = gdalMetadata[key] origin_is_nansat = True else: tmpGdalMetadata[newKey] = gdalMetadata[key] gdalMetadata = tmpGdalMetadata fileExt = os.path.splitext(inputFileName)[1] # Get file names from dataset or subdataset subDatasets = gdalDataset.GetSubDatasets() if len(subDatasets) == 0: filenames = [inputFileName] else: filenames = [f[0] for f in subDatasets] # add bands with metadata and corresponding values to the empty VRT metaDict = [] xDatasetSource = '' yDatasetSource = '' firstXSize = 0 firstYSize = 0 for _, filename in enumerate(filenames): subDataset = gdal.Open(filename) # choose the first dataset whith grid if (firstXSize == 0 and firstYSize == 0 and subDataset.RasterXSize > 1 and subDataset.RasterYSize > 1): firstXSize = subDataset.RasterXSize firstYSize = subDataset.RasterYSize firstSubDataset = subDataset # get projection from the first subDataset projection = firstSubDataset.GetProjection() # take bands whose sizes are same as the first band. if (subDataset.RasterXSize == firstXSize and subDataset.RasterYSize == firstYSize): if projection == '': projection = subDataset.GetProjection() if ('GEOLOCATION_X_DATASET' in filename or 'longitude' in filename): xDatasetSource = filename elif ('GEOLOCATION_Y_DATASET' in filename or 'latitude' in filename): yDatasetSource = filename else: for iBand in range(subDataset.RasterCount): subBand = subDataset.GetRasterBand(iBand+1) bandMetadata = subBand.GetMetadata_Dict() if 'PixelFunctionType' in bandMetadata: bandMetadata.pop('PixelFunctionType') sourceBands = iBand + 1 # sourceBands = i*subDataset.RasterCount + iBand + 1 # generate src metadata src = {'SourceFilename': filename, 'SourceBand': sourceBands} # set scale ratio and scale offset scaleRatio = bandMetadata.get( 'ScaleRatio', bandMetadata.get( 'scale', bandMetadata.get('scale_factor', ''))) if len(scaleRatio) > 0: src['ScaleRatio'] = scaleRatio scaleOffset = bandMetadata.get( 'ScaleOffset', bandMetadata.get( 'offset', bandMetadata.get( 'add_offset', ''))) if len(scaleOffset) > 0: src['ScaleOffset'] = scaleOffset # sate DataType src['DataType'] = subBand.DataType # generate dst metadata # get all metadata from input band dst = bandMetadata # set wkv and bandname dst['wkv'] = bandMetadata.get('standard_name', '') # first, try the name metadata if 'name' in bandMetadata: bandName = bandMetadata['name'] else: # if it doesn't exist get name from NETCDF_VARNAME bandName = bandMetadata.get('NETCDF_VARNAME', '') if len(bandName) == 0: bandName = bandMetadata.get( 'dods_variable', '' ) # remove digits added by gdal in # exporting to netcdf... if (len(bandName) > 0 and origin_is_nansat and fileExt == '.nc'): if bandName[-1:].isdigit(): bandName = bandName[:-1] if bandName[-1:].isdigit(): bandName = bandName[:-1] # if still no bandname, create one if len(bandName) == 0: bandName = 'band_%03d' % iBand dst['name'] = bandName # remove non-necessary metadata from dst for rmMetadata in rmMetadatas: if rmMetadata in dst: dst.pop(rmMetadata) # append band with src and dst dictionaries metaDict.append({'src': src, 'dst': dst}) # create empty VRT dataset with geolocation only self._init_from_gdal_dataset(firstSubDataset, metadata=gdalMetadata) # add bands with metadata and corresponding values to the empty VRT self.create_bands(metaDict) self._create_complex_bands(filenames) if len(projection) == 0: # projection was not set automatically # get projection from GCPProjection projection = geoMetadata.get('GCPProjection', '') if len(projection) == 0: # no projection was found in dataset or metadata: # generate WGS84 by default projection = NSR().wkt # fix problem with MET.NO files where a, b given in m and XC/YC in km if ('UNIT["kilometre"' in projection and ',SPHEROID["Spheroid",6378273,7.331926543631893e-12]' in projection): projection = projection.replace( ',SPHEROID["Spheroid",6378273,7.331926543631893e-12]', '') # set projection self.dataset.SetProjection(self.repare_projection(projection)) # check if GCPs were added from input dataset gcps = firstSubDataset.GetGCPs() gcpProjection = firstSubDataset.GetGCPProjection() # if no GCPs in input dataset: try to add GCPs from metadata if not gcps: gcps = self.add_gcps_from_metadata(geoMetadata) # if yet no GCPs: try to add GCPs from variables if not gcps: gcps = self.add_gcps_from_variables(inputFileName) if gcps: if len(gcpProjection) == 0: # get GCP projection and repare gcpProjection = self.repare_projection(geoMetadata. get('GCPProjection', '')) # add GCPs to dataset self.dataset.SetGCPs(gcps, gcpProjection) self.dataset.SetProjection('') self._remove_geotransform() # Find proper bands and insert GEOLOCATION ARRAY into dataset if len(xDatasetSource) > 0 and len(yDatasetSource) > 0: self._add_geolocation(Geolocation.from_filenames(xDatasetSource, yDatasetSource)) elif not gcps: # if no GCPs found and not GEOLOCATION ARRAY set: # Set Nansat Geotransform if it is not set automatically geoTransform = self.dataset.GetGeoTransform() if len(geoTransform) == 0: geoTransformStr = geoMetadata.get('GeoTransform', '(0|1|0|0|0|0|1)') geoTransform = eval(geoTransformStr.replace('|', ',')) self.dataset.SetGeoTransform(geoTransform) subMetadata = firstSubDataset.GetMetadata() ### GET START TIME from METADATA time_coverage_start = None if 'start_time' in gdalMetadata: time_coverage_start = parse_time(gdalMetadata['start_time']) elif 'start_date' in gdalMetadata: time_coverage_start = parse_time(gdalMetadata['start_date']) elif 'time_coverage_start' in gdalMetadata: time_coverage_start = parse_time( gdalMetadata['time_coverage_start']) ### GET END TIME from METADATA time_coverage_end = None if 'stop_time' in gdalMetadata: time_coverage_end = parse_time(gdalMetadata['stop_time']) elif 'stop_date' in gdalMetadata: time_coverage_end = parse_time(gdalMetadata['stop_date']) elif 'time_coverage_stop' in gdalMetadata: time_coverage_end = parse_time( gdalMetadata['time_coverage_stop']) elif 'end_time' in gdalMetadata: time_coverage_end = parse_time(gdalMetadata['end_time']) elif 'end_date' in gdalMetadata: time_coverage_end = parse_time(gdalMetadata['end_date']) elif 'time_coverage_end' in gdalMetadata: time_coverage_end = parse_time( gdalMetadata['time_coverage_end']) ### GET start time from time variable if (time_coverage_start is None and 'time#standard_name' in subMetadata and subMetadata['time#standard_name'] == 'time' and 'time#units' in subMetadata): # get data from netcdf data ncFile = Dataset(inputFileName, 'r') time_var = ncFile.variables['time'] t0 = time_var[0] if len(time_var) == 1: t1 = t0 + 1 else: t1 = time_var[-1] time_units_start = parse(time_var.units, fuzzy=True, ignoretz=True) time_units_to_seconds = {'second' : 1.0, 'hour' : 60 * 60.0, 'day' : 24 * 60 * 60.0} for key in time_units_to_seconds: if key in time_var.units: factor = time_units_to_seconds[key] break time_coverage_start = time_units_start + datetime.timedelta(seconds=t0 * factor) time_coverage_end = time_units_start + datetime.timedelta(seconds=t1 * factor) ## finally set values of time_coverage start and end if available if time_coverage_start is not None: self.dataset.SetMetadataItem('time_coverage_start', time_coverage_start.isoformat()) if time_coverage_end is not None: self.dataset.SetMetadataItem('time_coverage_end', time_coverage_end.isoformat()) if 'sensor' not in gdalMetadata: self.dataset.SetMetadataItem('sensor', 'unknown') if 'satellite' not in gdalMetadata: self.dataset.SetMetadataItem('satellite', 'unknown') if 'source_type' not in gdalMetadata: self.dataset.SetMetadataItem('source_type', 'unknown') if 'platform' not in gdalMetadata: self.dataset.SetMetadataItem('platform', 'unknown') if 'instrument' not in gdalMetadata: self.dataset.SetMetadataItem('instrument', 'unknown') self.logger.info('Use generic mapper - OK!')
def __init__(self, filename, gdalDataset, gdalMetadata, **kwargs): ######################################## # Read metadata from binary file ######################################## try: fp = open(filename, 'rb') except IOError: raise WrongMapperError fp.seek(72) try: satNum = int(struct.unpack('<H', fp.read(2))[0]) except: raise WrongMapperError if satNum >= 11: isMetop = True else: isMetop = False if satNum in satIDs.keys(): satID = satIDs[satNum] else: raise WrongMapperError fp.seek(76) dataFormatNum = int(struct.unpack('<H', fp.read(2))[0]) if dataFormatNum in dataFormats.keys(): dataFormat = dataFormats[dataFormatNum] else: raise WrongMapperError fp.seek(dataSetQualityIndicatorOffset + 14) numScanLines = int(struct.unpack('<H', fp.read(2))[0]) numCalibratedScanLines = int(struct.unpack('<H', fp.read(2))[0]) missingScanLines = int(struct.unpack('<H', fp.read(2))[0]) if missingScanLines != 0: print('WARNING: Missing scanlines: ' + str(missingScanLines)) ################## # Read time ################## fp.seek(84) year = int(struct.unpack('<H', fp.read(2))[0]) dayofyear = int(struct.unpack('<H', fp.read(2))[0]) millisecondsOfDay = int(struct.unpack('<l', fp.read(4))[0]) time = ( datetime.datetime(year, 1, 1) + datetime.timedelta(dayofyear - 1, milliseconds=millisecondsOfDay)) ################################## # Read calibration information ################################## #IRcalibration = {} #fp.seek(202) #avh_h_irttcoef=[] #for i in range(24): # avh_h_irttcoef.append(int(struct.unpack('<H', fp.read(2))[0])) ##print avh_h_irttcoef #avh_h_albcnv=[] #for i in range(6): # avh_h_albcnv.append(int(struct.unpack('<l', fp.read(4))[0])) ##print avh_h_albcnv #fp.seek(280) #avh_h_radtempcnv = np.zeros((3,3)) #for IRchannelNo in range(3): # for coeffNo in range(3): # avh_h_radtempcnv[IRchannelNo, coeffNo] = \ # int(struct.unpack('<l', fp.read(4))[0]) #print avh_h_radtempcnv #IRcalibration['centralWavenumber'] = (avh_h_radtempcnv[:,0] / # [1E2, 1E3, 1E3]) #IRcalibration['c1'] = avh_h_radtempcnv[:,1] / 1E5 #IRcalibration['c2'] = avh_h_radtempcnv[:,2] / 1E6 ######################################################## # Read visible calibration coefficients per scanline # - for channels 1, 2, 3A ######################################################## #for scanline in range(1): # avh_calvis=np.zeros((3,3,5)) # fp.seek(headerLength + recordLength*scanline + 48) # for VISchannel in range(3): # for sets in range(3): # for coeff in range(5): # avh_calvis[sets, VISchannel, coeff] = \ # int(struct.unpack('<l', fp.read(4))[0]) # print avh_calvis # print '----' ######################################################## # Read IR calibration coefficients per scanline # - for channels 3B, 4, 5 ######################################################## #for scanline in range(1): # avh_calir=np.zeros((2,3,3)) # fp.seek(headerLength + recordLength*scanline + 228) # for IRchannelNo in range(3): # for setNo in range(2): # for coeffNo in range(3): # avh_calir[setNo, IRchannelNo, coeffNo] = \ # int(struct.unpack('<l', fp.read(4))[0]) #avh_filler2 = np.zeros(3) #for fillerNo in range(3): # avh_filler2[fillerNo] = int(struct.unpack('<l', fp.read(4))[0]) #setNo = 0 # Use operational set (the only available) #a = np.zeros((3,3)) #for IRchannelNo in range(3): # for coeffNo in range(3): # # NB: apparently stored "backwards", therefore 2-coeffNo # a[IRchannelNo, 2-coeffNo] = (avh_calir[setNo, IRchannelNo, # coeffNo] # / np.power(10, # avh_filler2[coeffNo])) # ########################### # Apply calibration ########################### #C = 410 #for IRchannelNo in range(3): # Ne = a[IRchannelNo,0] + a[IRchannelNo,1]*C + a[IRchannelNo,2]*C*C # vC = IRcalibration['centralWavenumber'][IRchannelNo] # c1 = -IRcalibration['c1'][IRchannelNo] # Note minus # c2 = IRcalibration['c2'][IRchannelNo] #print '-----' #print a[IRchannelNo,:] #print vC, c1, c2 #TeStar = c2*vC/np.log(1 + (c1*vC*vC*vC)/Ne) #Te = c1 + c2*TeStar #print Ne, TeStar, Te #print '-----' #sys.exit('stop') ########################### # Make Geolocation Arrays ########################### srcRasterYSize = numCalibratedScanLines # Making VRT with raw (unscaled) lon and lat # (smaller bands than full dataset) self.band_vrts = { 'RawGeolocVRT': VRT(srcRasterXSize=51, srcRasterYSize=srcRasterYSize) } RawGeolocMetaDict = [] for lonlatNo in range(1, 3): RawGeolocMetaDict.append({ 'src': { 'SourceFilename': filename, 'SourceBand': 0, 'SourceType': "RawRasterBand", 'DataType': gdal.GDT_Int32, 'ImageOffset': (headerLength + 640 + (lonlatNo - 1) * 4), 'PixelOffset': 8, 'LineOffset': recordLength, 'ByteOrder': 'LSB' }, 'dst': {} }) self.band_vrts['RawGeolocVRT'].create_bands(RawGeolocMetaDict) # Make derived GeolocVRT with scaled lon and lat self.band_vrts['GeolocVRT'] = VRT(srcRasterXSize=51, srcRasterYSize=srcRasterYSize) GeolocMetaDict = [] for lonlatNo in range(1, 3): GeolocMetaDict.append({ 'src': { 'SourceFilename': (self.band_vrts['RawGeolocVRT'].filename), 'SourceBand': lonlatNo, 'ScaleRatio': 0.0001, 'ScaleOffset': 0, 'DataType': gdal.GDT_Int32 }, 'dst': {} }) self.band_vrts['GeolocVRT'].create_bands(GeolocMetaDict) GeolocObject = Geolocation( x_vRT=self.band_vrts['GeolocVRT'], y_vRT=self.band_vrts['GeolocVRT'], x_band=2, y_band=1, # x = lon, y = lat line_offset=0, pixel_offset=25, line_step=1, pixel_step=40) ####################### # Initialize dataset ####################### # create empty VRT dataset with geolocation only # (from Geolocation Array) self._init_from_dataset_params( 2048, numCalibratedScanLines, (0, 1, 0, numCalibratedScanLines, 0, -1), GeolocObject.d['SRS']) self._add_geolocation(GeolocObject) ################## # Create bands ################## metaDict = [] ch = ({}, {}, {}, {}, {}, {}) ch[1]['wavelength'] = 0.63 ch[2]['wavelength'] = 0.86 ch[3]['wavelength'] = '1.6 or 3.7 mum' ch[4]['wavelength'] = 10.8 ch[5]['wavelength'] = 12.0 ch[1]['minmax'] = '0 700' ch[2]['minmax'] = '0 700' ch[3]['minmax'] = '0 800' ch[4]['minmax'] = '400 1000' ch[5]['minmax'] = '400 1000' for bandNo in range(1, 6): metaDict.append({ 'src': { 'SourceFilename': filename, 'SourceBand': 0, 'SourceType': "RawRasterBand", 'dataType': gdal.GDT_UInt16, 'ImageOffset': imageOffset + (bandNo - 1) * 2, 'PixelOffset': 10, 'LineOffset': recordLength, 'ByteOrder': 'LSB' }, 'dst': { 'dataType': gdal.GDT_UInt16, 'wkv': 'raw_counts', 'colormap': 'gray', 'wavelength': ch[bandNo]['wavelength'], 'minmax': ch[bandNo]['minmax'], 'unit': "1" } }) self.create_bands(metaDict) # Adding valid time to dataset self.dataset.SetMetadataItem('time_coverage_start', time.isoformat()) self.dataset.SetMetadataItem('time_coverage_end', time.isoformat()) return