def __init__(self):
super(VenusL1ImageFileReader, self).__init__()
self._plugin = MajaVenusPlugin()
self._Satellite = "VEnUS"
self.headerHandler = None
self._l1toa_pipeline = OtbPipelineManager()
self._l1pix_pipeline = OtbPipelineManager()
self._l2pix_pipeline = OtbPipelineManager()
self._edg_pipeline = OtbPipelineManager()
self._l2toa_pipeline = OtbPipelineManager()
self._l2edg_pipeline = OtbPipelineManager()
self._sat_pipeline = OtbPipelineManager()
self._sol_pipeline = OtbPipelineManager()
self._dtmvie_pipeline = OtbPipelineManager()
self._shadowvie_pipeline = OtbPipelineManager()
self._toascalar = ""
self._l1pix = ""
self._l2pix = ""
self._edgsub = ""
self._toasub = ""
self._l2toa = ""
self._l2edg = ""
self._l2sat = ""
self._satsub = ""
self._cla = ""
self._sol1 = ""
self._sol2 = ""
self._dtmvie = ""
self._shadowvie = ""
self._reall1nodata = -10
self._meanZenithMap = {}
self._meanAzimuthMap = {}
def __init__(self):
self.plugin = MajaVenusPlugin()
self.m_hdrfilename = ""
self.m_TOAImageFileName = ""
self.m_TOAHeaderFileName = ""
self.m_CLAImageFileName = ""
self.m_CLAHeaderFileName = ""
self.m_SOLImageFileName = ""
self.m_SOLHeaderFileName = ""
self.m_VIEImageFileName = ""
self.m_VIEHeaderFileName = ""
def __init__(self):
super(MajaVenusL1ImageInformations, self).__init__()
self._plugin = MajaVenusPlugin()
self.UniqueSatellite = self._plugin.UniqueSatellite
self.HeaderHandler = None
self.FilenamesProvider = VenusL1ImageFilenames()
class VenusL1ImageFileReader(L1ImageReaderBase):
TOAFirstChannel = 1
TOALastChannel = 12
PIXChannel = 14
SATChannel = 13
PIXNumberOfComponentsPerPixel = 12
SATNumberOfComponentsPerPixel = 12
SOL1ChannelB1 = "?&sdataidx=0"
SOL1ChannelB2 = "?&sdataidx=1"
SOL2ChannelB1 = "?&sdataidx=2"
SOL2ChannelB2 = "?&sdataidx=3"
VIEB5ChannelB1 = "?&sdataidx=0"
VIEB5ChannelB2 = "?&sdataidx=1"
VIEB6ChannelB1 = "?&sdataidx=6"
VIEB6ChannelB2 = "?&sdataidx=7"
def __init__(self):
super(VenusL1ImageFileReader, self).__init__()
self._plugin = MajaVenusPlugin()
self._Satellite = "VEnUS"
self.headerHandler = None
self._l1toa_pipeline = OtbPipelineManager()
self._l1pix_pipeline = OtbPipelineManager()
self._l2pix_pipeline = OtbPipelineManager()
self._edg_pipeline = OtbPipelineManager()
self._l2toa_pipeline = OtbPipelineManager()
self._l2edg_pipeline = OtbPipelineManager()
self._sat_pipeline = OtbPipelineManager()
self._sol_pipeline = OtbPipelineManager()
self._dtmvie_pipeline = OtbPipelineManager()
self._shadowvie_pipeline = OtbPipelineManager()
self._toascalar = ""
self._l1pix = ""
self._l2pix = ""
self._edgsub = ""
self._toasub = ""
self._l2toa = ""
self._l2edg = ""
self._l2sat = ""
self._satsub = ""
self._cla = ""
self._sol1 = ""
self._sol2 = ""
self._dtmvie = ""
self._shadowvie = ""
self._reall1nodata = -10
self._meanZenithMap = {}
self._meanAzimuthMap = {}
def can_read(self, plugin_name):
return plugin_name == "VENUS"
def read(self, product_info, app_handler, l2comm, dem, pReadL1Mode):
"""product_info,plugin, l2comm,mode
:param product_info: L1ImageInformationsBase
:param pReadL1Mode: ReadL1ModeType
:return:
"""
LOGGER.debug("Start Venus L1 ImageFileReader ...")
product_filename = product_info.HeaderFilename
LOGGER.debug("Start Venus L1 ImageFileReader with the filename: " +
product_filename)
self._plugin.initialize(app_handler)
self.headerHandler = product_info.HeaderHandler
self._dem = dem
# working_dir = get_working_directory("L1Read_", app_handler.get_working_directory())
working_dir = app_handler.get_directory_manager(
).get_temporary_directory("L1Read_", do_always_remove=True)
self.ReadL1Mode = pReadL1Mode
self._GIPPL2COMMHandler = l2comm
l_BandsDefinitions = self._plugin.BandsDefinitions
# --------------------------------------
# Initialize the Image filename provider
l_FilenameProvider = VenusL1ImageFilenames()
#product_info.FilenamesProvider
IsValidSatellite = (l_FilenameProvider.initialize(product_filename)
is not False)
if not IsValidSatellite:
raise MajaPluginVenusException(
"The file <{}> is not a valid Venus L1 product.".format(
product_filename))
# *********************************************************************************************************
# Register the Header o the Input image file
# *********************************************************************************************************
LOGGER.debug("Load the Venus L1 Header file : '" + product_filename +
"'")
l_L1XMLHandler = HeaderImageEarthExplorerXMLFileHandler(
product_filename)
# *********************************************************************************************************
# TOA Reader connection
# *********************************************************************************************************
l_L1NoData = l_L1XMLHandler.get_no_data_value_as_double()
l_ReflectanceQuantificationValue = l_L1XMLHandler.get_reflectance_quantification_value(
)
l_reflectanceMultiplicationValues = []
if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")):
l_factor = xml_tools.as_float_list(
l2comm.get_value("CalAdjustFactor"))
if len(l_factor) != (VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1):
raise MajaPluginVenusException(
"Not the same number of Calibration coeffs than L1 bands")
for i in range(0, len(l_factor)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue * l_factor[i])
else:
for i in range(VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue)
l_RealL1NoData = l_L1NoData * l_ReflectanceQuantificationValue
# *********************************************************************************************************
# L1 TOA image pipeline connection
# *********************************************************************************************************
if not l_FilenameProvider.m_TOAImageFileName:
raise MajaPluginVenusException(
"VenusL1ImageFileReader : The TOA image does not exist !")
tmp_l1toa_roi = os.path.join(working_dir, "l1toa_roi.tif")
app_l1_toa_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName, [
channel
for channel in range(VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1)
],
tmp_l1toa_roi,
write_output=False)
self._l1toa_pipeline.add_otb_app(app_l1_toa_roi)
tmp_sat_roi = os.path.join(working_dir, "sat_roi.tif")
app_sat_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName,
[VenusL1ImageFileReader.SATChannel - 1],
tmp_sat_roi,
write_output=False)
self._sat_pipeline.add_otb_app(app_sat_roi)
#Multiply scalar by quantif
tmp_l1toa_mbs = os.path.join(working_dir, "l1toa.tif")
app_l1toa_mbs = multiply_by_scalar(
app_l1_toa_roi.getoutput().get("out"),
l_ReflectanceQuantificationValue,
output_image=tmp_l1toa_mbs,
write_output=False)
self._l1toa_pipeline.add_otb_app(app_l1toa_mbs)
# update all extract ROI in once
write_images([
app_l1toa_mbs.getoutput().get("out"),
app_sat_roi.getoutput().get("out")
], [tmp_l1toa_mbs, tmp_sat_roi])
self._toascalar = tmp_l1toa_mbs
# *********************************************************************************************************
# L1 PIX image pipeline connection
# *********************************************************************************************************
tmp_l1pix_roi = os.path.join(working_dir, "l1pix.tif")
app_l1_pix_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName,
[VenusL1ImageFileReader.PIXChannel - 1],
tmp_l1pix_roi + ":uint16",
write_output=False)
self._l1pix_pipeline.add_otb_app(app_l1_pix_roi)
self._l1pix = app_l1_pix_roi.getoutput().get("out")
# *********************************************************************************************************
# START READ L1 for ALGORITHMS
# *********************************************************************************************************
if pReadL1Mode == ReadL1Mode.READ_L1_MODE_FOR_ALGORITHMS:
# *********************************************************************************************************
# L2 PIX image pipeline connection
# *********************************************************************************************************
# LAIG-FA-MAC-131720-CS : New for 4.2
# Before resample, binarytovector -> resample -> vectortobinary
tmp_l2pix_bin2vec = os.path.join(working_dir, "l2pix_bin2vec.tif")
param_l2pix_bin2vec = {
"im": app_l1_pix_roi.getoutput().get("out"),
"out": tmp_l2pix_bin2vec + ":uint8",
"nbcomp": VenusL1ImageFileReader.PIXNumberOfComponentsPerPixel
}
app_l2pix_bin2vec = OtbAppHandler("BinaryToVector",
param_l2pix_bin2vec,
write_output=False)
self._l2pix_pipeline.add_otb_app(app_l2pix_bin2vec)
tmp_l2pix_resample = os.path.join(working_dir,
"l2pix_resample.tif")
app_l2pix_resample = resample(
app_l2pix_bin2vec.getoutput().get("out"),
self._dem.ALTList[0],
tmp_l2pix_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
threshold=0.0,
write_output=False)
self._l2pix_pipeline.add_otb_app(app_l2pix_resample)
#L2 PIX is concatenate
tmp_l2pix_binconcat = os.path.join(working_dir, "l2pix.tif")
param_l2pix_binconcat = {
"im": app_l2pix_resample.getoutput().get("out"),
"out": tmp_l2pix_binconcat + ":uint16"
}
app_l2pix_binconcat = OtbAppHandler("BinaryConcatenate",
param_l2pix_binconcat,
write_output=False)
self._l2pix = app_l2pix_binconcat.getoutput().get("out")
self._l2pix_pipeline.add_otb_app(app_l2pix_binconcat)
# *********************************************************************************************************
# L2 EDG image pipeline connection
# *********************************************************************************************************
tmp_edg_thresholder = os.path.join(working_dir,
"edg_thresholder1.tif")
param_edg_thresholder1 = {
"im": self._toascalar,
"thresholdvalue": l_RealL1NoData,
"equalvalue": 255,
"outsidevalue": 0,
"out": tmp_edg_thresholder + ":uint8"
}
app_edg_thresholder1 = OtbAppHandler("OneBandEqualThreshold",
param_edg_thresholder1,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_thresholder1)
tmp_edg_resample = os.path.join(working_dir, "edg_resample.tif")
app_edg_resample = resample(
app_edg_thresholder1.getoutput().get("out"),
self._dem.ALTList[0],
tmp_edg_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_resample)
# Threshold the output
out_sub_edg = os.path.join(working_dir, "edg_thresholder2.tif")
param_edg_thresholder2 = {
"im": app_edg_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 1,
"outsidevalue": 0,
"out": out_sub_edg + ":uint8"
}
app_edg_thresholder2 = OtbAppHandler("OneBandEqualThreshold",
param_edg_thresholder2,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_thresholder2)
# *********************************************************************************************************
# IPEDGSub image pipeline connection
# *********************************************************************************************************
tmp_edgsub_resample = os.path.join(working_dir,
"edgsub_resample.tif")
app_edgsub_resample = resample(
app_edg_thresholder1.getoutput().get("out"),
self._dem.ALC,
tmp_edgsub_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=12.0,
write_output=True)
self._edg_pipeline.add_otb_app(app_edgsub_resample)
# Threshold the output
out_sub_edgsub = os.path.join(working_dir, "edgsub.tif")
param_edgsub_thresholder2 = {
"im": app_edgsub_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 0,
"outsidevalue": 1,
"out": out_sub_edgsub + ":uint8"
}
app_edgsub_thresholder2 = OtbAppHandler("OneBandEqualThreshold",
param_edgsub_thresholder2,
write_output=True)
self._edgsub = app_edgsub_thresholder2.getoutput().get("out")
self._edg_pipeline.add_otb_app(app_edgsub_thresholder2)
# *********************************************************************************************************
# L2 TOA image pipeline connection
# *********************************************************************************************************
tmp_l2toa_resample = os.path.join(working_dir,
"l2toa_resample.tif")
app_l2toa_resample = resample(self._toascalar,
self._dem.ALTList[0],
tmp_l2toa_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
self._l2toa_pipeline.add_otb_app(app_l2toa_resample)
l2toa_list = []
l_toathresholdminvalue = 0
l_toathresholvalue = -10
#Apply EDG mask on l2toa resampled
tmp_l2toa = os.path.join(working_dir, "l2toa.tif")
app_l2toa = apply_mask(app_l2toa_resample.getoutput().get("out"),
app_edg_thresholder2.getoutput().get("out"),
l_toathresholvalue,
tmp_l2toa,
write_output=False)
self._l2toa = app_l2toa.getoutput().get("out")
self._l2toa_pipeline.add_otb_app(app_l2toa)
# *********************************************************************************************************
# TOA Sub image pipeline connection
# *********************************************************************************************************
tmp_toasub_resample = os.path.join(working_dir,
"toasub_resample.tif")
app_toasub_resample = resample(self._toascalar,
self._dem.ALC,
tmp_toasub_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
write_output=True)
self._l2toa_pipeline.add_otb_app(app_toasub_resample)
# Threshold the output
out_edgsub_threshold = os.path.join(working_dir,
"edgsubthreshold.tif")
param_edgsub_threshold = {
"im": app_edgsub_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 1,
"outsidevalue": 0,
"out": out_edgsub_threshold + ":uint8"
}
app_edgsub_threshold = OtbAppHandler("OneBandEqualThreshold",
param_edgsub_threshold,
write_output=True)
self._edg_pipeline.add_otb_app(app_edgsub_threshold)
tmp_l2subtoa = os.path.join(working_dir, "toasub.tif")
app_l2subtoa = apply_mask(
app_toasub_resample.getoutput().get("out"),
app_edgsub_threshold.getoutput().get("out"),
l_toathresholvalue,
tmp_l2subtoa,
write_output=True)
self._toasub = app_l2subtoa.getoutput().get("out")
self._l2toa_pipeline.add_otb_app(app_l2subtoa)
# *********************************************************************************************************
# L2EDG - Actualization of the L2 edge mask
# *********************************************************************************************************
#tmp_l2edg_threshold = os.path.join(working_dir, "l2edg_threshold.tif")
#app_l2edg_threshold = binary_threshold(self._edgsub,
# lower_threshold=0,
# inside_value=1000,
# outside_value=0,
# output_image=tmp_l2edg_threshold + ":uint8",
# write_output=True)
#self._l2edg_pipeline.add_otb_app(app_l2edg_threshold)
tmp_l2edg_resample = os.path.join(working_dir, "l2edg.tif")
app_l2edg_resample = resample(self._edgsub,
self._dem.ALTList[0],
tmp_l2edg_resample + ":uint8",
OtbResampleType.LINEAR,
padradius=4.0,
threshold=0.001,
write_output=True)
self._l2edg = app_l2edg_resample.getoutput().get("out")
self._l2edg_pipeline.add_otb_app(app_l2edg_resample)
# *********************************************************************************************************
# SAT image pipeline connection
# *********************************************************************************************************
tmp_sat_bin2vec = os.path.join(working_dir, "sat_bin2vec.tif")
param_sat_bin2vec = {
"im": tmp_sat_roi,
"out": tmp_sat_bin2vec + ":uint8",
"nbcomp": VenusL1ImageFileReader.SATNumberOfComponentsPerPixel
}
app_sat_bin2vec = OtbAppHandler("BinaryToVector",
param_sat_bin2vec,
write_output=False)
self._sat_pipeline.add_otb_app(app_sat_bin2vec)
l_l2sat_thresholdvalue = l2comm.get_value_f("SaturationThreshold")
tmp_sat_resample = os.path.join(working_dir, "l2sat.tif")
app_sat_resample = resample(app_sat_bin2vec.getoutput().get("out"),
self._dem.ALTList[0],
tmp_sat_resample + ":uint8",
OtbResampleType.BCO,
padradius=4.0,
threshold=l_l2sat_thresholdvalue,
write_output=False)
self._l2sat = app_sat_resample.getoutput().get("out")
self._sat_pipeline.add_otb_app(app_sat_resample)
# *********************************************************************************************************
# IPSAT Sub image pipeline connection
# *********************************************************************************************************
l_sat_subthresholdvalue = l2comm.get_value_f(
"SaturationThresholdSub")
tmp_satsub_resample = os.path.join(working_dir, "satsub.tif")
app_satsub_resample = resample(
app_sat_bin2vec.getoutput().get("out"),
self._dem.ALC,
tmp_satsub_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
threshold=l_sat_subthresholdvalue)
self._satsub = app_satsub_resample.getoutput().get("out")
self._sat_pipeline.add_otb_app(app_satsub_resample)
# *********************************************************************************************************
# CLA image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - CLA image filename: '" +
l_FilenameProvider.m_CLAImageFileName + "'")
if not l_FilenameProvider.m_CLAImageFileName:
raise MajaPluginVenusException(
"The CLA image does not exist !! ")
self._cla = l_FilenameProvider.m_CLAImageFileName
# *********************************************************************************************************
# SOL1 image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - SOL image filename: '" +
l_FilenameProvider.m_SOLImageFileName + "'")
if not l_FilenameProvider.m_SOLImageFileName:
raise MajaPluginVenusException(
"The SOL image does not exist !! ")
mtdat = GdalDatasetInfo(l_FilenameProvider.m_TOAImageFileName)
toaarea = Area()
toaarea.size = mtdat.size
toaarea.origin = mtdat.origin
toaarea.spacing = mtdat.pixel_size
l_SOLHeaderHandler = HeaderImageEarthExplorerXMLFileHandler(
l_FilenameProvider.m_SOLHeaderFileName)
l_L1SOLSubsamplingFactor = l_SOLHeaderHandler.get_sampling_factor()
LOGGER.debug(l_L1SOLSubsamplingFactor)
# SOL1
tmp_sol1_b1 = os.path.join(working_dir, "sol1_B1.tif")
app_sol1_b1 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL1ChannelB1,
toaarea.spacing[0],
tmp_sol1_b1,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol1_b1)
tmp_sol1_b2 = os.path.join(working_dir, "sol1_B2.tif")
app_sol1_b2 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL1ChannelB2,
(-1) * toaarea.spacing[1],
tmp_sol1_b2,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol1_b2)
tmp_sol1_concat = os.path.join(working_dir, "sol1_concat.tif")
param_sol1_concat = {
"il": [
app_sol1_b1.getoutput().get("out"),
app_sol1_b2.getoutput().get("out")
],
"out":
tmp_sol1_concat
}
app_sol1_concat = OtbAppHandler("ConcatenateDoubleImages",
param_sol1_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_sol1_concat.getoutput().get("out"),
l_L1SOLSubsamplingFactor)
self._sol_pipeline.add_otb_app(app_sol1_concat)
tmp_sol1_resample = os.path.join(working_dir, "sol1.tif")
app_sol1_resample = resample(
app_sol1_concat.getoutput().get("out"),
self._dem.ALC,
tmp_sol1_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._sol1 = app_sol1_resample.getoutput().get("out")
self._sol_pipeline.add_otb_app(app_sol1_resample)
# SOL2
tmp_sol2_b1 = os.path.join(working_dir, "sol2_B1.tif")
app_sol2_b1 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL2ChannelB1,
toaarea.spacing[0],
tmp_sol2_b1,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol2_b1)
tmp_sol2_b2 = os.path.join(working_dir, "sol2_B2.tif")
app_sol2_b2 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL2ChannelB2,
(-1) * toaarea.spacing[1],
tmp_sol2_b2,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol2_b2)
tmp_sol2_concat = os.path.join(working_dir, "sol2_concat.tif")
param_sol2_concat = {
"il": [
app_sol2_b1.getoutput().get("out"),
app_sol2_b2.getoutput().get("out")
],
"out":
tmp_sol2_concat
}
app_sol2_concat = OtbAppHandler("ConcatenateDoubleImages",
param_sol2_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_sol2_concat.getoutput().get("out"),
l_L1SOLSubsamplingFactor)
self._sol_pipeline.add_otb_app(app_sol2_concat)
tmp_sol2_resample = os.path.join(working_dir, "sol2.tif")
app_sol2_resample = resample(
app_sol2_concat.getoutput().get("out"),
self._dem.ALC,
tmp_sol2_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._sol2 = app_sol2_resample.getoutput().get("out")
self._sol_pipeline.add_otb_app(app_sol2_resample)
# *********************************************************************************************************
# DTMVIE image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - VIE image filename: '" +
l_FilenameProvider.m_VIEImageFileName + "'")
l_VIEHeaderHandler = HeaderImageEarthExplorerXMLFileHandler(
l_FilenameProvider.m_VIEHeaderFileName)
l_L1VIESubsamplingFactor = l_VIEHeaderHandler.get_sampling_factor()
LOGGER.debug(l_L1VIESubsamplingFactor)
tmp_vieb5b1_mult = os.path.join(working_dir, "vie5b1_mult.tif")
app_vieb5b1_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB5ChannelB1,
toaarea.spacing[0],
tmp_vieb5b1_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb5b1_mult)
tmp_vieb5b2_mult = os.path.join(working_dir, "vie5b2_mult.tif")
app_vieb5b2_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB5ChannelB2,
(-1) * toaarea.spacing[1],
tmp_vieb5b2_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb5b2_mult)
tmp_vieb6b1_mult = os.path.join(working_dir, "vie6b1_mult.tif")
app_vieb6b1_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB6ChannelB1,
toaarea.spacing[0],
tmp_vieb6b1_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb6b1_mult)
tmp_vieb6b2_mult = os.path.join(working_dir, "vie6b2_mult.tif")
app_vieb6b2_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB6ChannelB2,
(-1) * toaarea.spacing[1],
tmp_vieb6b2_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb6b2_mult)
tmp_dtmvie_concat = os.path.join(working_dir, "dtmvie_concat.tif")
param_dtmvie_concat = {
"il": [
app_vieb5b1_mult.getoutput().get("out"),
app_vieb5b2_mult.getoutput().get("out"),
app_vieb6b1_mult.getoutput().get("out"),
app_vieb6b2_mult.getoutput().get("out")
],
"out":
tmp_dtmvie_concat
}
app_dtmvie_concat = OtbAppHandler("ConcatenateDoubleImages",
param_dtmvie_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_dtmvie_concat.getoutput().get("out"),
l_L1VIESubsamplingFactor)
self._dtmvie_pipeline.add_otb_app(app_dtmvie_concat)
tmp_dtmvie_resample = os.path.join(working_dir, "dtmvie.tif")
app_dtmvie_resample = resample(
app_dtmvie_concat.getoutput().get("out"),
self._dem.ALC,
tmp_dtmvie_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._dtmvie = app_dtmvie_resample.getoutput().get("out")
self._dtmvie_pipeline.add_otb_app(app_dtmvie_resample)
# *********************************************************************************************************
# VIE image pipeline connection
# *********************************************************************************************************
tmp_shadowvie_concat = os.path.join(working_dir,
"shadowvie_concat.tif")
param_shadowvie_concat = {
"il": [
app_vieb5b1_mult.getoutput().get("out"),
app_vieb5b2_mult.getoutput().get("out")
],
"out":
tmp_shadowvie_concat
}
app_shadowvie_concat = OtbAppHandler("ConcatenateDoubleImages",
param_shadowvie_concat)
self._shadowvie_pipeline.add_otb_app(app_shadowvie_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_shadowvie_concat.getoutput().get("out"),
l_L1VIESubsamplingFactor)
tmp_shadowvie_resample = os.path.join(working_dir, "shadowvie.tif")
app_shadowvie_resample = resample(
app_shadowvie_concat.getoutput().get("out"),
self._dem.ALC,
tmp_shadowvie_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._shadowvie = app_shadowvie_resample.getoutput().get("out")
self._shadowvie_pipeline.add_otb_app(app_shadowvie_resample)
# Fill the datas
self.dict_of_vals["IPEDGSubOutput"] = self._edgsub
self.dict_of_vals["SOL1Image"] = self._sol1
self.dict_of_vals["SOL2Image"] = self._sol2
self.dict_of_vals["DTMVIEImage"] = self._dtmvie
self.dict_of_vals["IPTOASubOutput"] = self._toasub
self.dict_of_vals["L2TOAImageList"] = [self._l2toa]
self.dict_of_vals["ViewingZenithMeanMap"] = self._meanZenithMap
self.dict_of_vals["ViewingAzimuthMeanMap"] = self._meanAzimuthMap
self.dict_of_vals["CLAImage"] = self._cla
self.dict_of_vals["IPSATSubOutput"] = self._satsub
self.dict_of_vals["ShadowVIEImage"] = self._shadowvie
if self._plugin.CirrusMasking:
l_CirrusBandCode = l2comm.get_value("CirrusBandCode")
l_CirrusBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CirrusBandCode)
tmp = os.path.join(working_dir, "l1toacirrus.tif")
app = extract_roi(self._toascalar, [l_CirrusBandIdx - 1], tmp)
self.dict_of_vals["L1TOACirrusImage"] = app.getoutput().get(
"out")
self.dict_of_vals["L2EDGOutputList"] = [self._l2edg]
self.dict_of_vals["L2SATImageList"] = [self._l2sat]
self.dict_of_vals["L2PIXImageList"] = [self._l2pix]
self.dict_of_vals["L1PIXImageList"] = [self._l1pix]
self.dict_of_vals["L1TOAImageList"] = [self._toascalar]
class MajaVenusL1ImageInformations(L1ImageInformationsBase):
def __init__(self):
super(MajaVenusL1ImageInformations, self).__init__()
self._plugin = MajaVenusPlugin()
self.UniqueSatellite = self._plugin.UniqueSatellite
self.HeaderHandler = None
self.FilenamesProvider = VenusL1ImageFilenames()
def detect_l1_products(self, input_directory, l_ListOfL1Products):
LOGGER.info("Start Venus L1 DetectL1Products in " + input_directory)
l_ListOfFilenames = [os.path.join(input_directory, f) for f in os.listdir(input_directory) if os.path.isfile(os.path.join(input_directory, f))]
l_NbFiles = len(l_ListOfFilenames)
LOGGER.debug("Nb files in the sub directory: " + str(l_NbFiles))
for filename in l_ListOfFilenames:
LOGGER.debug("Test if the filename '" + filename + "' is a Venus L1 product (VSC_L1VALD and .DBL extension conditions) ..." )
# Detect the VSC_L1VALD and .DBL file
if "VSC_L1VALD" in filename:
if os.path.splitext(filename)[1] == ".DBL":
l_ListOfL1Products.append(os.path.join(input_directory,filename))
elif os.path.splitext(filename)[1] == ".HDR":
l_DBLFilename= os.path.splitext(filename)[0] + ".DBL"
if not os.path.exists(l_DBLFilename):
l_ListOfL1Products.append(l_DBLFilename)
LOGGER.debug(l_ListOfL1Products)
# FA LEVEE SUR TMA VENUS - V 4.1 - Corrige dans patch 4.1.1 et reportee dans 4.2
# If no L1VALD product, try to detect the L1NOTV products
if len(l_ListOfL1Products)==0:
for filename in l_ListOfFilenames:
LOGGER.debug(
"Test if the filename '" + filename + "' is a Venus L1 product (VSC_L1NOTV and .DBL extension conditions) ...")
# Detect the VSC_L1VALD and .DBL file
if "VSC_L1NOTV" in filename:
if os.path.splitext(filename)[1] == ".DBL":
l_ListOfL1Products.append(os.path.join(input_directory, filename))
elif os.path.splitext(filename)[1] == ".HDR":
l_DBLFilename = os.path.splitext(filename)[0] + ".DBL"
if not os.path.exists(l_DBLFilename):
l_ListOfL1Products.append(l_DBLFilename)
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