def get_area_def(self, dataset_id):
"""Get the area definition of the band."""
pdict = {}
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['ssp_longitude']
if dataset_id['name'] == 'HRV':
pdict['nlines'] = self.mda['hrv_number_of_lines']
pdict['ncols'] = self.mda['hrv_number_of_columns']
pdict['a_name'] = 'geos_seviri_hrv'
pdict['a_desc'] = 'SEVIRI high resolution channel area'
pdict['p_id'] = 'seviri_hrv'
if self.mda['is_full_disk']:
# handle full disk HRV data with two separated area definitions
[
upper_area_extent, lower_area_extent, upper_nlines,
upper_ncols, lower_nlines, lower_ncols
] = self.get_area_extent(dataset_id)
# upper area
pdict[
'a_desc'] = 'SEVIRI high resolution channel, upper window'
pdict['nlines'] = upper_nlines
pdict['ncols'] = upper_ncols
upper_area = get_area_definition(pdict, upper_area_extent)
# lower area
pdict[
'a_desc'] = 'SEVIRI high resolution channel, lower window'
pdict['nlines'] = lower_nlines
pdict['ncols'] = lower_ncols
lower_area = get_area_definition(pdict, lower_area_extent)
area = geometry.StackedAreaDefinition(lower_area, upper_area)
area = area.squeeze()
else:
# if the HRV data is in a ROI, the HRV channel is delivered in one area
area = get_area_definition(pdict,
self.get_area_extent(dataset_id))
else:
pdict['nlines'] = self.mda['number_of_lines']
pdict['ncols'] = self.mda['number_of_columns']
pdict['a_name'] = 'geos_seviri_visir'
pdict['a_desc'] = 'SEVIRI low resolution channel area'
pdict['p_id'] = 'seviri_visir'
area = get_area_definition(pdict, self.get_area_extent(dataset_id))
return area
def get_area_def(self, dsid):
"""Get the area definition."""
del dsid
pdict = {}
pdict['cfac'] = np.uint32(self.proj_info['CFAC'])
pdict['lfac'] = np.uint32(self.proj_info['LFAC'])
pdict['coff'] = np.float32(self.proj_info['COFF'])
pdict['loff'] = -np.float32(self.proj_info['LOFF']) + 1
pdict['a'] = float(self.proj_info['earth_equatorial_radius'] * 1000)
pdict['h'] = float(self.proj_info['distance_from_earth_center'] *
1000 - pdict['a'])
pdict['b'] = float(self.proj_info['earth_polar_radius'] * 1000)
pdict['ssp_lon'] = float(self.proj_info['sub_lon'])
pdict['nlines'] = int(self.data_info['number_of_lines'])
pdict['ncols'] = int(self.data_info['number_of_columns'])
pdict['scandir'] = 'N2S'
pdict['loff'] = pdict['loff'] + (self.segment_number * pdict['nlines'])
aex = get_area_extent(pdict)
pdict['a_name'] = self.observation_area
pdict['a_desc'] = "AHI {} area".format(self.observation_area)
pdict['p_id'] = 'geosh8'
area = get_area_definition(pdict, aex)
self.area = area
return area
def get_area_def(self, ds_id):
ds_get_name = self._get_dsname(ds_id)
ds_shape = self[ds_get_name + '/shape']
geoloc = self.geoloc
pdict = {}
pdict['cfac'] = np.int32(geoloc[0])
pdict['lfac'] = np.int32(geoloc[1])
pdict['coff'] = np.float32(geoloc[2])
pdict['loff'] = -np.float32(geoloc[3])
# Unfortunately this dataset does not store a, b or h.
# We assume a and b here, and calculate h from altitude
# a and b are from SEVIRI data HRIT header (201912101300)
pdict['a'] = 6378169
pdict['b'] = 6356583.8
pdict['h'] = self.alt - pdict['a']
pdict['ssp_lon'] = self.projlon
pdict['ncols'] = int(ds_shape[0])
pdict['nlines'] = int(ds_shape[1])
# Force scandir to SEVIRI default, not known from file
pdict['scandir'] = 'S2N'
pdict['a_name'] = 'geosmsg'
if ds_id.name == 'HRV':
pdict['a_desc'] = 'MSG/SEVIRI HRV channel area'
pdict['p_id'] = 'msg_hires'
else:
pdict['a_desc'] = 'MSG/SEVIRI low resolution channel area'
pdict['p_id'] = 'msg_lowres'
aex = get_area_extent(pdict)
area = get_area_definition(pdict, aex)
return area
def get_area_def(self, dataset_id):
"""Get the area definition of the band.
In general, image data from one window/area is available. For the HRV channel in FES mode, however,
data from two windows ('Lower' and 'Upper') are available. Hence, we collect lists of area-extents
and corresponding number of image lines/columns. In case of FES HRV data, two area definitions are
computed, stacked and squeezed. For other cases, the lists will only have one entry each, from which
a single area definition is computed.
Note that the AreaDefinition area extents returned by this function for Native data will be slightly
different compared to the area extents returned by the SEVIRI HRIT reader.
This is due to slightly different pixel size values when calculated using the data available in the files. E.g.
for the 3 km grid:
``Native: data15hd['ImageDescription']['ReferenceGridVIS_IR']['ColumnDirGridStep'] == 3000.4031658172607``
``HRIT: np.deg2rad(2.**16 / pdict['lfac']) * pdict['h'] == 3000.4032785810186``
This results in the Native 3 km full-disk area extents being approx. 20 cm shorter in each direction.
The method for calculating the area extents used by the HRIT reader (CFAC/LFAC mechanism) keeps the
highest level of numeric precision and is used as reference by EUM. For this reason, the standard area
definitions defined in the `areas.yaml` file correspond to the HRIT ones.
"""
pdict = {}
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['ssp_longitude']
area_naming_input_dict = {
'platform_name': 'msg',
'instrument_name': 'seviri',
'resolution': int(dataset_id['resolution'])
}
area_naming = get_geos_area_naming({
**area_naming_input_dict,
**get_service_mode('seviri', pdict['ssp_lon'])
})
pdict['a_name'] = area_naming['area_id']
pdict['a_desc'] = area_naming['description']
pdict['p_id'] = ""
area_extent = self.get_area_extent(dataset_id)
areas = list()
for aex, nlines, ncolumns in zip(area_extent['area_extent'],
area_extent['nlines'],
area_extent['ncolumns']):
pdict['nlines'] = nlines
pdict['ncols'] = ncolumns
areas.append(get_area_definition(pdict, aex))
if len(areas) == 2:
area = geometry.StackedAreaDefinition(areas[0], areas[1])
area = area.squeeze()
else:
area = areas[0]
return area
def get_area_def(self, dsid):
"""Get area definition for this file."""
pdict = {}
pdict['a'] = self.nc.attrs['earth_equatorial_radius']
pdict['b'] = self.nc.attrs['earth_polar_radius']
pdict['h'] = self.nc.attrs['nominal_satellite_height'] - pdict['a']
pdict['ssp_lon'] = self.nc.attrs['sub_longitude'] * 180 / np.pi # it's in radians?
pdict['ncols'] = self.nc.attrs['number_of_columns']
pdict['nlines'] = self.nc.attrs['number_of_lines']
obs_mode = self.nc.attrs['observation_mode']
resolution = self.nc.attrs['channel_spatial_resolution']
pdict['cfac'] = self.nc.attrs['cfac']
pdict['coff'] = self.nc.attrs['coff']
pdict['lfac'] = self.nc.attrs['lfac']
pdict['loff'] = self.nc.attrs['loff']
# AMI grid appears offset, we can not use the standard get_area_extent
bit_shift = 2**16
ll_x = (0 - pdict['coff'] - 0.5) * bit_shift / pdict['cfac']
ll_y = -(0 - pdict['loff'] - 0.5) * bit_shift / pdict['lfac']
ur_x = (pdict['ncols'] - pdict['coff'] + 0.5) * bit_shift / pdict['cfac']
ur_y = -(pdict['nlines'] - pdict['loff'] + 0.5) * bit_shift / pdict['lfac']
area_extent = make_ext(ll_x, ur_x, ll_y, ur_y, pdict['h'])
pdict['a_name'] = 'ami_geos_{}'.format(obs_mode.lower())
pdict['a_desc'] = 'AMI {} Area at {} resolution'.format(obs_mode, resolution)
pdict['p_id'] = 'ami_fixed_grid'
fg_area_def = get_area_definition(pdict, area_extent)
return fg_area_def
def get_area_def(self, dataset_id):
"""Get the area definition of the band."""
proj_dict = self._get_proj_dict(dataset_id)
area_extent = get_area_extent(proj_dict)
area = get_area_definition(proj_dict, area_extent)
self.area = area
return area
def get_area_def(self, dsid):
"""Get the area definition of the band."""
pdict = {}
pdict['cfac'] = np.int32(self.mda['cfac'])
pdict['lfac'] = np.int32(self.mda['lfac'])
pdict['coff'] = np.float32(self.mda['coff'])
pdict['loff'] = np.float32(self.mda['loff'])
pdict['a'] = 6378169.00
pdict['b'] = 6356583.80
pdict['h'] = 35785831.00
pdict['scandir'] = 'N2S'
pdict['ssp_lon'] = self.mda['projection_parameters']['SSP_longitude']
pdict['nlines'] = int(self.mda['number_of_lines'])
pdict['ncols'] = int(self.mda['number_of_columns'])
pdict['loff'] = pdict['nlines'] - pdict['loff']
pdict['a_name'] = 'geosgoms'
pdict['a_desc'] = 'Electro-L/GOMS channel area'
pdict['p_id'] = 'goms'
area_extent = get_area_extent(pdict)
area = get_area_definition(pdict, area_extent)
self.area = area
return area
def get_area_def(self, dsid):
"""Get area definition for this file."""
pdict = {}
pdict['a'] = self.nc.attrs['earth_equatorial_radius']
pdict['b'] = self.nc.attrs['earth_polar_radius']
pdict['h'] = self.nc.attrs['nominal_satellite_height'] - pdict['a']
pdict['ssp_lon'] = self.nc.attrs[
'sub_longitude'] * 180 / np.pi # it's in radians?
pdict['ncols'] = self.nc.attrs['number_of_columns']
pdict['nlines'] = self.nc.attrs['number_of_lines']
obs_mode = self.nc.attrs['observation_mode']
resolution = self.nc.attrs['channel_spatial_resolution']
# Example offset: 11000.5
# the 'get_area_extent' will handle this half pixel for us
pdict['cfac'] = self.nc.attrs['cfac']
pdict['coff'] = self.nc.attrs['coff']
pdict['lfac'] = -self.nc.attrs['lfac']
pdict['loff'] = self.nc.attrs['loff']
pdict['scandir'] = 'N2S'
pdict['a_name'] = 'ami_geos_{}'.format(obs_mode.lower())
pdict['a_desc'] = 'AMI {} Area at {} resolution'.format(
obs_mode, resolution)
pdict['p_id'] = 'ami_fixed_grid'
area_extent = get_area_extent(pdict)
fg_area_def = get_area_definition(pdict, area_extent)
return fg_area_def
def get_area_def(self, key):
"""Get the area definition."""
# Coordination Group for Meteorological Satellites LRIT/HRIT Global Specification
# https://www.cgms-info.org/documents/cgms-lrit-hrit-global-specification-(v2-8-of-30-oct-2013).pdf
res = key['resolution']
pdict = {}
pdict['coff'] = _COFF_list[_resolution_list.index(res)]
pdict['loff'] = _LOFF_list[_resolution_list.index(res)]
pdict['cfac'] = _CFAC_list[_resolution_list.index(res)]
pdict['lfac'] = _LFAC_list[_resolution_list.index(res)]
pdict['a'] = self.file_content['/attr/dEA'] * 1E3 # equator radius (m)
pdict['b'] = pdict['a'] * (
1 - 1 / self.file_content['/attr/dObRecFlat']) # polar radius (m)
pdict['h'] = self.file_content[
'/attr/NOMSatHeight'] # the altitude of satellite (m)
pdict['ssp_lon'] = self.file_content['/attr/NOMCenterLon']
pdict['nlines'] = self.file_content['/attr/RegLength']
pdict['ncols'] = self.file_content['/attr/RegWidth']
pdict['scandir'] = 'S2N'
b500 = ['C02']
b1000 = ['C01', 'C03']
b2000 = ['C04', 'C05', 'C06', 'C07']
pdict['a_desc'] = "AGRI {} area".format(
self.filename_info['observation_type'])
if (key['name'] in b500):
pdict['a_name'] = self.filename_info['observation_type'] + '_500m'
pdict['p_id'] = 'FY-4A, 500m'
elif (key['name'] in b1000):
pdict['a_name'] = self.filename_info['observation_type'] + '_1000m'
pdict['p_id'] = 'FY-4A, 1000m'
elif (key['name'] in b2000):
pdict['a_name'] = self.filename_info['observation_type'] + '_2000m'
pdict['p_id'] = 'FY-4A, 2000m'
else:
pdict['a_name'] = self.filename_info['observation_type'] + '_2000m'
pdict['p_id'] = 'FY-4A, 4000m'
pdict['coff'] = pdict['coff'] + 0.5
pdict['nlines'] = pdict['nlines'] - 1
pdict['ncols'] = pdict['ncols'] - 1
pdict['loff'] = (pdict['loff'] -
self.file_content['/attr/End Line Number'] + 0.5)
area_extent = get_area_extent(pdict)
area_extent = (area_extent[0] + 2000, area_extent[1],
area_extent[2] + 2000, area_extent[3])
pdict['nlines'] = pdict['nlines'] + 1
pdict['ncols'] = pdict['ncols'] + 1
area = get_area_definition(pdict, area_extent)
return area
def get_area_def(self, dataset_id):
"""Return the area definition for a dataset."""
# The area extension depends on the resolution of the dataset
area_dict = self._area_dict.copy()
area_dict['resolution'] = dataset_id.resolution
area_extent = calculate_area_extent(area_dict)
# Call the get_area_definition function to obtain the area
area_def = get_area_definition(self._pdict, area_extent)
return area_def
def get_area_def(self, dataset_id):
"""Return the area definition for a dataset."""
self._area_dict['column_step'] = dataset_id.resolution
self._area_dict['line_step'] = dataset_id.resolution
area_extent = calculate_area_extent(self._area_dict)
# Call the get_area_definition function to obtain the area
area_def = get_area_definition(self._pdict, area_extent)
return area_def
def _compute_area_def(self):
"""Compute the area definition.
Returns:
AreaDefinition: A pyresample AreaDefinition object containing the area definition.
"""
# Read the projection data from the mtg_geos_projection variable
a = float(self._projection.attrs['semi_major_axis'])
b = float(self._projection.attrs['semi_minor_axis'])
h = float(self._projection.attrs['perspective_point_height'])
# TODO sweep_angle_axis value not handled at the moment, therefore commented out
# sweep_axis = self._projection.attrs['sweep_angle_axis']
# Coordinates of the pixel in radians
x = self.nc['x']
y = self.nc['y']
# TODO conversion to radians: offset and scale factor are missing from some test NetCDF file
# TODO the next two lines should be removed when the offset and scale factor are correctly configured
if not hasattr(x, 'standard_name'):
x = np.radians(x * 0.003202134 - 8.914740401)
y = np.radians(y * 0.003202134 - 8.914740401)
# Convert to degrees as required by the make_ext function
x_deg = np.degrees(x)
y_deg = np.degrees(y)
# Select the extreme points of the extension area
x_l, x_r = x_deg.values[0], x_deg.values[-1]
y_l, y_u = y_deg.values[0], y_deg.values[-1]
# Compute the extension area in meters
area_extent = make_ext(x_l, x_r, y_l, y_u, h)
# Assemble the projection definition dictionary
p_dict = {
'nlines': self.nlines,
'ncols': self.ncols,
'ssp_lon': self.ssp_lon,
'a': a,
'b': b,
'h': h,
'a_name': 'FCI Area', # TODO to be confirmed
'a_desc': 'Area for FCI instrument', # TODO to be confirmed
'p_id': 'geos'
}
# Compute the area definition
area_def = get_area_definition(p_dict, area_extent)
return area_def
def test_get_area_definition(self):
"""Test the retrieval of the area definition."""
pdict, extent = self.make_pdict_ext(1, 'N2S')
good_res = (-3000.4032785810186, -3000.4032785810186)
a_def = get_area_definition(pdict, extent)
self.assertEqual(a_def.area_id, pdict['a_name'])
self.assertEqual(a_def.resolution, good_res)
self.assertEqual(a_def.proj_dict['proj'], 'geos')
self.assertEqual(a_def.proj_dict['units'], 'm')
self.assertEqual(a_def.proj_dict['a'], 6378169)
self.assertEqual(a_def.proj_dict['b'], 6356583.8)
self.assertEqual(a_def.proj_dict['h'], 35785831)
def get_area_def(self, dataset_id):
"""Get the area def.
Note that the AreaDefinition area extents returned by this function for NetCDF data will be slightly
different compared to the area extents returned by the SEVIRI HRIT reader.
This is due to slightly different pixel size values when calculated using the data available in the files. E.g.
for the 3 km grid:
``NetCDF: self.nc.attrs['vis_ir_column_dir_grid_step'] == 3000.4031658172607``
``HRIT: np.deg2rad(2.**16 / pdict['lfac']) * pdict['h'] == 3000.4032785810186``
This results in the Native 3 km full-disk area extents being approx. 20 cm shorter in each direction.
The method for calculating the area extents used by the HRIT reader (CFAC/LFAC mechanism) keeps the
highest level of numeric precision and is used as reference by EUM. For this reason, the standard area
definitions defined in the `areas.yaml` file correspond to the HRIT ones.
"""
pdict = {}
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['ssp_longitude']
area_naming_input_dict = {
'platform_name': 'msg',
'instrument_name': 'seviri',
'resolution': int(dataset_id['resolution'])
}
area_naming = get_geos_area_naming({
**area_naming_input_dict,
**get_service_mode('seviri', pdict['ssp_lon'])
})
if dataset_id['name'] == 'HRV':
pdict['nlines'] = self.mda['hrv_number_of_lines']
pdict['ncols'] = self.mda['hrv_number_of_columns']
pdict['a_name'] = area_naming['area_id']
pdict['a_desc'] = area_naming['description']
pdict['p_id'] = ""
else:
pdict['nlines'] = self.mda['number_of_lines']
pdict['ncols'] = self.mda['number_of_columns']
pdict['a_name'] = area_naming['area_id']
pdict['a_desc'] = area_naming['description']
pdict['p_id'] = ""
area = get_area_definition(pdict, self.get_area_extent(dataset_id))
return area
def test_get_area_definition(self):
"""Test the retrieval of the area definition."""
from pyresample.utils import proj4_radius_parameters
pdict, extent = self.make_pdict_ext(1, 'N2S')
good_res = (-3000.4032785810186, -3000.4032785810186)
a_def = get_area_definition(pdict, extent)
self.assertEqual(a_def.area_id, pdict['a_name'])
self.assertEqual(a_def.resolution, good_res)
self.assertEqual(a_def.proj_dict['proj'], 'geos')
self.assertEqual(a_def.proj_dict['units'], 'm')
a, b = proj4_radius_parameters(a_def.proj_dict)
self.assertEqual(a, 6378169)
self.assertEqual(b, 6356583.8)
self.assertEqual(a_def.proj_dict['h'], 35785831)
def get_area_def(self, dataset_id):
"""Get the area definition of the band.
In general, image data from one window/area is available. For the HRV channel in FES mode, however,
data from two windows ('Lower' and 'Upper') are available. Hence, we collect lists of area-extents
and corresponding number of image lines/columns. In case of FES HRV data, two area definitions are
computed, stacked and squeezed. For other cases, the lists will only have one entry each, from which
a single area definition is computed.
"""
pdict = {}
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['ssp_longitude']
if dataset_id['name'] == 'HRV':
res = 1.0
pdict['p_id'] = 'seviri_hrv'
else:
res = 3.0
pdict['p_id'] = 'seviri_visir'
service_mode = get_service_mode(pdict['ssp_lon'])
pdict['a_name'] = 'msg_seviri_%s_%.0fkm' % (service_mode['name'], res)
pdict[
'a_desc'] = 'SEVIRI %s area definition with %.0f km resolution' % (
service_mode['desc'], res)
area_extent = self.get_area_extent(dataset_id)
areas = list()
for aex, nlines, ncolumns in zip(area_extent['area_extent'],
area_extent['nlines'],
area_extent['ncolumns']):
pdict['nlines'] = nlines
pdict['ncols'] = ncolumns
areas.append(get_area_definition(pdict, aex))
if len(areas) == 2:
area = geometry.StackedAreaDefinition(areas[0], areas[1])
area = area.squeeze()
else:
area = areas[0]
return area
def _get_area_def(self):
"""Get the area definition of the band."""
pdict = {
'cfac': np.int32(self.mda['cfac']),
'lfac': np.int32(self.mda['lfac']),
'coff': np.float32(self.mda['coff']),
'loff': self._get_line_offset(),
'ncols': int(self.mda['number_of_columns']),
'nlines': int(self.mda['number_of_lines']),
'scandir': 'N2S',
'a': float(self.mda['projection_parameters']['a']),
'b': float(self.mda['projection_parameters']['b']),
'h': float(self.mda['projection_parameters']['h']),
'ssp_lon': float(self.mda['projection_parameters']['SSP_longitude']),
'a_name': AREA_NAMES[self.area_id]['short'],
'a_desc': AREA_NAMES[self.area_id]['long'],
'p_id': 'geosmsg'
}
area_extent = get_area_extent(pdict)
return get_area_definition(pdict, area_extent)
def get_area_def(self, dsid):
pdict = {}
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['ssp_longitude']
if dsid.name == 'HRV':
pdict['nlines'] = self.mda['hrv_number_of_lines']
pdict['ncols'] = self.mda['hrv_number_of_columns']
pdict['a_name'] = 'geosmsg_hrv'
pdict['a_desc'] = 'MSG/SEVIRI high resolution channel area'
pdict['p_id'] = 'msg_hires'
else:
pdict['nlines'] = self.mda['number_of_lines']
pdict['ncols'] = self.mda['number_of_columns']
pdict['a_name'] = 'geosmsg'
pdict['a_desc'] = 'MSG/SEVIRI low resolution channel area'
pdict['p_id'] = 'msg_lowres'
area = get_area_definition(pdict, self.get_area_extent(dsid))
return area
def get_area_def(self, im_size, projection_longitude):
"""Create MVIRI area definition."""
proj_params = self._get_proj_params(im_size, projection_longitude)
extent = get_area_extent(proj_params)
return get_area_definition(proj_params, extent)
def get_area_def(self, dsid):
"""Get the area definition of the band."""
# Common parameters for both HRV and other channels
nlines = int(self.mda['number_of_lines'])
loff = np.float32(self.mda['loff'])
pdict = {}
pdict['cfac'] = np.int32(self.mda['cfac'])
pdict['lfac'] = np.int32(self.mda['lfac'])
pdict['coff'] = np.float32(self.mda['coff'])
pdict['a'] = self.mda['projection_parameters']['a']
pdict['b'] = self.mda['projection_parameters']['b']
pdict['h'] = self.mda['projection_parameters']['h']
pdict['ssp_lon'] = self.mda['projection_parameters']['SSP_longitude']
pdict['nlines'] = nlines
pdict['ncols'] = int(self.mda['number_of_columns'])
if (self.prologue['ImageDescription']['Level15ImageProduction']
['ImageProcDirection'] == 0):
pdict['scandir'] = 'N2S'
else:
pdict['scandir'] = 'S2N'
# Compute area definition for non-HRV channels:
if dsid['name'] != 'HRV':
pdict['loff'] = loff - nlines
aex = self._get_area_extent(pdict)
pdict['a_name'] = 'geosmsg'
pdict['a_desc'] = 'MSG/SEVIRI low resolution channel area'
pdict['p_id'] = 'msg_lowres'
area = get_area_definition(pdict, aex)
self.area = area
return self.area
segment_number = self.mda['segment_sequence_number']
current_first_line = ((segment_number -
self.mda['planned_start_segment_number'])
* pdict['nlines'])
# Or, if we are processing HRV:
pdict['a_name'] = 'geosmsg_hrv'
pdict['p_id'] = 'msg_hires'
bounds = self.epilogue['ImageProductionStats']['ActualL15CoverageHRV'].copy()
if self.fill_hrv:
bounds['UpperEastColumnActual'] = 1
bounds['UpperWestColumnActual'] = HRV_NUM_COLUMNS
bounds['LowerEastColumnActual'] = 1
bounds['LowerWestColumnActual'] = HRV_NUM_COLUMNS
pdict['ncols'] = HRV_NUM_COLUMNS
upper_south_line = bounds[
'LowerNorthLineActual'] - current_first_line - 1
upper_south_line = min(max(upper_south_line, 0), pdict['nlines'])
lower_coff = (5566 - bounds['LowerEastColumnActual'] + 1)
upper_coff = (5566 - bounds['UpperEastColumnActual'] + 1)
# First we look at the lower window
pdict['nlines'] = upper_south_line
pdict['loff'] = loff - upper_south_line
pdict['coff'] = lower_coff
pdict['a_desc'] = 'MSG/SEVIRI high resolution channel, lower window'
lower_area_extent = self._get_area_extent(pdict)
lower_area = get_area_definition(pdict, lower_area_extent)
# Now the upper window
pdict['nlines'] = nlines - upper_south_line
pdict['loff'] = loff - pdict['nlines'] - upper_south_line
pdict['coff'] = upper_coff
pdict['a_desc'] = 'MSG/SEVIRI high resolution channel, upper window'
upper_area_extent = self._get_area_extent(pdict)
upper_area = get_area_definition(pdict, upper_area_extent)
area = geometry.StackedAreaDefinition(lower_area, upper_area)
self.area = area.squeeze()
return self.area
