def __init__(self, main_xml_file, validate=False, schema_path=None):
"""
Constructor
"""
LOGGER.debug("Loading " + main_xml_file)
self.main_xml_file = main_xml_file
self.root = xml_tools.get_root_xml(self.main_xml_file, deannotate=True)
self.orig_root = xml_tools.get_root_xml(self.main_xml_file,
deannotate=False)
self.nss = self.root.nsmap
if validate and schema_path is not None:
xml_tools.check_xml(main_xml_file, schema_path)
def get_detfoo_index_detector_list(maskFilename, shift):
l_result = {}
# Load the MSK_DETFOO gml file
maskHandler = get_root_xml(maskFilename, deannotate=True)
# Get the mask feature nodes
# as : <eop:MaskFeature gml:id="detector_footprint-B02-10-2">
xnodes = get_all_values(maskHandler,
"//*[local-name(.) = 'MaskFeature']")
# Two indices : the detector index and the feature index
detId = 0
# For each feature
for i in range(len(xnodes)):
feat = xnodes[i]
# Get the attribute of the feature node
# "detector_footprint-B02-10-2"
attribute = list(feat.items())[0][1]
element = attribute.split('-')
# Get the detector index and the feature index
detId = int(element[-2])
featId = int(element[-1])
l_result[featId + shift] = detId
return l_result
def __init__(self, gipp_filename):
self.gipp_filename = gipp_filename
self.root = get_root_xml(self.gipp_filename, deannotate=True)
self.l2_site_values = {}
for key, value in list(GIPP_SITE_HANDLER_XPATH.items()):
result = get_only_value(self.root, value)
if result is not None:
self.l2_site_values[key] = result
def __init__(self, gipp_filename):
self.gipp_filename = gipp_filename
self.root = xml_tools.get_root_xml(self.gipp_filename, deannotate=True)
self.l2_comm_values = {}
for key, value in list(GIPP_COMM_HANDLER_XPATH.items()):
result = xml_tools.get_only_value(self.root, value, check=True)
if result is not None:
self.l2_comm_values[key] = result
def get_detfoo_index_shift(maskFilename):
"""
Get the shift between the detector index and the feature index in the MSK_DETFOO mask
:param maskFilename: string
:return:
"""
shift = 0
# Load the MSK_DETFOO gml file
maskHandler = get_root_xml(maskFilename, deannotate=True)
# Get the mask feature nodes
# as : <eop:MaskFeature gml:id="detector_footprint-B02-10-2">
xnodes = get_all_values(maskHandler,
"//*[local-name(.) = 'MaskFeature']")
# Two indices : the detector index and the feature index
detId = 0
# For each feature
for i in range(len(xnodes)):
feat = xnodes[i]
prevShift = shift
prevDetId = detId
# "detector_footprint-B02-10-2"
attribute = list(feat.items())[0][1]
element = attribute.split('-')
# Get the detector index and the feature index
detId = int(element[-2])
featId = int(element[-1])
# The shift between those two indices must be constant
# because it should not have a gap of detector between to consecutive features
shift = detId - featId
# Check the index values of the next features
if (i > 0) and ((shift != prevShift) or (detId != prevDetId + 1)):
LOGGER.warn(
"Sentinel2L1ImageFileReaderBase::get_detfoo_index_shift: The detector indices are not in ascending order "
"or do not have a constant shift with the feature indices in the MSK_DETFOO "
+ maskFilename + " !")
return False, shift
return True, shift
def get_mask_feature_count(maskFilename, regex=None):
"""
Get the number of layers in a gml file
:param maskFilename:
:return:
"""
maskHandler = get_root_xml(maskFilename, deannotate=True)
xnodes = get_all_values(maskHandler, "//*[local-name(.) = 'MaskFeature']")
if xnodes is not None:
if regex is None:
return len(xnodes)
else:
nb = 0
for x in xnodes:
for a in list(x.items()):
if regex in a[1]:
nb = nb + 1
return nb
else:
return 0
def __init__(self, main_xml_file):
"""
Constructor
"""
self.root = get_root_xml(main_xml_file, deannotate=True)
self.angles = MajaL2Angles(self.root)
def setUp(self):
self.granule_xml = A_PRODUCT_S2_L1.get("granule_xml_fullpath")
self.root = get_root_xml(self.granule_xml)
self.nss = self.root.nsmap
self.assertTrue(os.path.isfile(self.granule_xml))
def setUp(self):
self.main_xml = A_PRODUCT_S2_L2.get("main_xml_fullpath")
self.root = get_root_xml(self.main_xml, deannotate=True)
self.assertTrue(os.path.isfile(self.main_xml))
def initialize(self, product_filename, validate=False, schema_path=None):
LOGGER.info("Start Venus L1 Initialize on product " + product_filename)
l_hdrfilename = os.path.splitext(product_filename)[0] + ".HDR"
l_CanLoad = xml_tools.can_load_file(l_hdrfilename)
if not l_CanLoad:
return False
rootNode = xml_tools.get_root_xml(l_hdrfilename, deannotate=True)
self.Satellite = xml_tools.get_xml_string_value(rootNode, "//Mission")
if not self._plugin.is_valid_with_satellite(self.Satellite):
LOGGER.debug("The L1 product '" + product_filename + "' with satellite '" + self.Satellite + "' is not a VENUS product !")
self.SatelliteID = self.Satellite.upper()
self.PluginName = self._plugin.PluginName
self.Prefix = "VE"
l_File_Type = xml_tools.get_xml_string_value(rootNode, "//File_Type")
filenamekey = l_File_Type.split("_")
self.FileCategory = filenamekey[0]
self.LevelType = filenamekey[1]
self.FileClass = xml_tools.get_xml_string_value(rootNode, "//File_Class")
self.Site = xml_tools.get_xml_string_value(rootNode, "//Instance_Id/Nick_Name")
self.ReferenceSiteDefinitionId = xml_tools.get_xml_string_value(rootNode, "//Reference_SiteDefinition_Id")
l_AcquisitionDateTime = xml_tools.get_xml_string_value(rootNode, "//Product_Information/Acquisition_Date_Time")
self.ProductDate = date_utils.get_datetime_from_utc(l_AcquisitionDateTime)
self.ProductDateStr = self.ProductDate.strftime('%Y%m%d')
LOGGER.debug("Product Date: " + self.ProductDateStr)
self.ProductId = xml_tools.get_xml_string_value(rootNode, "//Fixed_Header/File_Name")
genDate = xml_tools.get_xml_string_value(rootNode, "//Processing_Information/Date_Time")
genDate = genDate[4:]
if genDate[-1] != 'Z':
genDate = genDate + 'Z'
self.GenerationDateStr = genDate
self.AcquisitionStart = l_AcquisitionDateTime[4:]
self.OrbitNumber = xml_tools.get_xml_string_value(rootNode, "//Product_Information/Acquisition_Orbit_Number")
self.SpectralContent = "XS"
self.FilenamesProvider.initialize(l_hdrfilename, validate=validate, schema_path=schema_path)
self.HeaderFilename = self.FilenamesProvider.m_hdrfilename
self.SOLImageFileName = self.FilenamesProvider.m_SOLImageFileName
self.SOLHeaderFileName = self.FilenamesProvider.m_SOLHeaderFileName
self.VIEImageFileName = self.FilenamesProvider.m_VIEImageFileName
self.VIEHeaderFileName = self.FilenamesProvider.m_VIEHeaderFileName
self.HeaderHandler = VenusL1HeaderImageEarthExplorerXMLFileHandler(l_hdrfilename)
# Estimation of the coordinate of the central point
self.CenterCorner.longitude = self.HeaderHandler.get_useful_image_geo_coverage_center_corner_long()
self.CenterCorner.latitude = self.HeaderHandler.get_useful_image_geo_coverage_center_corner_lat()
self.CenterCorner.column = self.HeaderHandler.get_useful_image_geo_coverage_center_corner_column()
self.CenterCorner.line = self.HeaderHandler.get_useful_image_geo_coverage_center_corner_line()
# Initialize the Validity Start/Stop
self.UTCValidityStart = l_AcquisitionDateTime
self.UTCValidityStop = l_AcquisitionDateTime
# Initialize the Viewing angles for each detectors (Zenith and Azimuth)
self.ListOfViewingZenithAnglesPerBandAtL2CoarseResolution = []
self.ListOfViewingAzimuthAnglesPerBandAtL2CoarseResolution = []
l_meanViewingZenith = 0.0
l_meanViewingAzimuth = 0.0
l_count = 0.0
l_BandsDefinitions = self._plugin.BandsDefinitions
for det in l_BandsDefinitions.DetectorMap:
l_Zenith = self.HeaderHandler.get_useful_image_center_view_angle_zenith(det)
l_Azimuth = self.HeaderHandler.get_useful_image_center_view_angle_azimuth(det)
l_meanViewingZenith += l_Zenith
l_meanViewingAzimuth += l_Azimuth
l_count += 1.0
self.ListOfViewingZenithAnglesPerBandAtL2CoarseResolution.append(str(l_Zenith))
self.ListOfViewingAzimuthAnglesPerBandAtL2CoarseResolution.append(str(l_Azimuth))
self.ListOfViewingAnglesPerBandAtL2CoarseResolution.append(
{ "incidence_zenith_angle": str(l_Zenith),
"incidence_azimuth_angle": str(l_Azimuth)
})
self.ViewingAngle = {
"incidence_zenith_angle": str(l_meanViewingZenith / l_count),
"incidence_azimuth_angle": str(l_meanViewingAzimuth / l_count)
}
# Fill the L2 resolution angles
self.ListOfViewingAnglesPerBandAtL2Resolution = self.ListOfViewingAnglesPerBandAtL2CoarseResolution
# Solar Angles
self.SolarAngle = {
"sun_zenith_angle": self.HeaderHandler.get_useful_image_image_center_solar_angle_zenith(),
"sun_azimuth_angle": self.HeaderHandler.get_useful_image_image_center_solar_angle_azimuth()
}
# Detect pixel size and product size
originX = xml_tools.get_xml_float_value(rootNode, "//Geo_Referencing_Information/Product_Coverage/Cartographic/Upper_Left_Corner/X")
originY = xml_tools.get_xml_float_value(rootNode, "//Geo_Referencing_Information/Product_Coverage/Cartographic/Upper_Left_Corner/Y")
pixSizeX = xml_tools.get_xml_float_value(rootNode, "//Product_Sampling/By_Column")
pixSizeY = xml_tools.get_xml_float_value(rootNode, "//Product_Sampling/By_Line")
nbCol = xml_tools.get_xml_int_value(rootNode, "//Image_Information/Size/Columns")
nbRow = xml_tools.get_xml_int_value(rootNode, "//Image_Information/Size/Lines")
gridColStep = (nbCol - 1.0) * pixSizeX
gridRowStep = (nbRow - 1.0) * pixSizeY
gridColStepStr = f"{gridColStep:.1f}"
gridRowStepStr = f"{gridRowStep:.1f}"
# Solar angle grid
ula = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Upper_Left_Corner/Azimuth")
ulz = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Upper_Left_Corner/Zenith")
ura = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Upper_Right_Corner/Azimuth")
urz = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Upper_Right_Corner/Zenith")
lla = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Lower_Left_Corner/Azimuth")
llz = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Lower_Left_Corner/Zenith")
lra = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Lower_Right_Corner/Azimuth")
lrz = xml_tools.get_xml_string_value(rootNode, "//Solar_Angles/Product/Lower_Right_Corner/Zenith")
self.SolarAngleGrid["StepUnit"] = "m"
self.SolarAngleGrid["ColStep"] = gridColStepStr
self.SolarAngleGrid["RowStep"] = gridRowStepStr
self.SolarAngleGrid["Azimuth"] = [ula+' '+ura, lla+' '+lra]
self.SolarAngleGrid["Zenith"] = [ulz+' '+urz, llz+' '+lrz]
# Viewing angle grids
detectors = [1,2,3,4]
self.ViewingAngleGrids = []
l_pathView = "//List_of_Viewing_Angles/Viewing_Angles[@sn='{}']/Product/{}"
for det in detectors:
ula = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Upper_Left_Corner/Azimuth"))
ulz = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Upper_Left_Corner/Zenith"))
ura = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Upper_Right_Corner/Azimuth"))
urz = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Upper_Right_Corner/Zenith"))
lla = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Lower_Left_Corner/Azimuth"))
llz = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Lower_Left_Corner/Zenith"))
lra = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Lower_Right_Corner/Azimuth"))
lrz = xml_tools.get_xml_string_value(rootNode, l_pathView.format(det,"Lower_Right_Corner/Zenith"))
self.ViewingAngleGrids.append({
"StepUnit":"m",
"ColStep":gridColStepStr,
"RowStep":gridRowStepStr,
"Detector":str(det),
"Azimuth":[ula+' '+ura, lla+' '+lra],
"Zenith":[ulz+' '+urz, llz+' '+lrz]
})
# Set Area by resolution
curArea = Area()
curArea.origin = (
f"{originX:.1f}",
f"{originY:.1f}")
curArea.spacing = (
f"{pixSizeX:.1f}",
f"{-pixSizeY:.1f}")
curArea.size = (
str(nbCol),
str(nbRow))
self.AreaByResolution = [curArea]
# Gather spectral information
l_resol = l_BandsDefinitions.ListOfL1Resolution[0]
l_pathAk = "//List_of_Aks/Ak[@sk='{}']"
l_pathPolarCoef = "//List_of_Polarization_Coefficients/Polarization_Coefficient[@sk='{}']"
l_pathWavelenghCentral = "//List_of_Band_Central_Wavelength/Band_Central_Wavelength[@sk='{}']"
self.SpectralInfo = []
for b, bidx in l_BandsDefinitions.L1BandMap.items():
bcode = l_BandsDefinitions.L1ListOfBandsMap[l_resol][bidx]
self.SpectralInfo.append({
"Band":b.replace("B0", "B"),
"Ak":xml_tools.get_xml_string_value(rootNode,l_pathAk.format(bcode)) ,
"PolarizationCoefficient":xml_tools.get_xml_string_value(rootNode,l_pathPolarCoef.format(bcode)),
"WavelengthCentral": xml_tools.get_xml_string_value(rootNode,l_pathWavelenghCentral.format(bcode))
})
# 4.2: New
# Set the L1 no data value
self.L1NoData = self.HeaderHandler.get_no_data_value_as_int()
# Set the reflectance quantification value
self.ReflectanceQuantification = self.HeaderHandler.get_reflectance_quantification_value()
# Computes the real value of the L1 NoData
self.RealL1NoData = self.L1NoData * self.ReflectanceQuantification
return True
