def get_solar_grids(self, dtm, solarAnglesFile, solH1, working):
solar_grid_filename = os.path.join(working, "solar_grid.tif")
# angle_list_to_image()
solarangle_grid_app = angle_list_to_image(dtm,
solarAnglesFile,
solar_grid_filename,
write_output=False)
# Multiply by the solar reference altitude
solar_grid_mult_filename = os.path.join(working, "solar_grid_mult.tif")
param_scaled_solar = {
"im": solarangle_grid_app.getoutput().get("out"),
"coef": float(solH1),
"out": solar_grid_mult_filename
}
rta_scal_app = OtbAppHandler("MultiplyByScalar",
param_scaled_solar,
write_output=False)
# Expand at L2Coarse.
solar_grid_resamp_filename = os.path.join(working,
"solar_grid_resamp.tif")
resample(rta_scal_app.getoutput().get("out"), dtm,
solar_grid_resamp_filename, OtbResampleType.LINEAR)
self._sol1image = solar_grid_resamp_filename
def generate_toa_sub_images(self, working):
dtm_coarse = self._dem.ALC
# For each band of the input product
tmp_sub_toa_pipe = OtbPipelineManager()
for i, toa in enumerate(self._toa_scalar_list):
# undersampling at L2CoarseResolution
toa_sub_image = os.path.join(working, "aot_sub_{}.tif".format(i))
app = resample(toa,
dtm_coarse,
toa_sub_image,
OtbResampleType.LINEAR_WITH_RADIUS,
write_output=False)
self._toa_sub_list.append(app.getoutput()["out"])
tmp_sub_toa_pipe.add_otb_app(app)
# end band loop
# *******************************************************************************************************
# TOA Sub image pipeline connection
# *******************************************************************************************************
toa_sub_image = os.path.join(working, "aot_sub.tif")
param_concatenate = {"il": self._toa_sub_list, "out": toa_sub_image}
OtbAppHandler("ConcatenateDoubleImages", param_concatenate)
self._sub_toa = toa_sub_image
tmp_sub_toa_pipe.free_otb_app()
def generate_l2_toa_images(self, l_ListOfL2Resolution, working_dir):
for l1res in range(len(l_ListOfL2Resolution)):
curL1Res = l_ListOfL2Resolution[l1res]
dtm = self._dem.ALTList[l1res]
l_ListOfL2BandCode = self._plugin.BandsDefinitions.get_list_of_l2_band_code(
curL1Res)
LOGGER.debug("Read the nb bands" + str(len(l_ListOfL2BandCode)) +
" of the TOA images...")
l_l1bandidx = [
self._plugin.BandsDefinitions.get_band_id_in_l1(b)
for b in l_ListOfL2BandCode
]
tmp_toa_resample = os.path.join(working_dir,
"tmp_toa_resample.tif")
app_toa_resample = resample(self._l1toaimagelist[l1res],
dtm,
tmp_toa_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
write_output=False)
self._l2toa_pipeline.add_otb_app(app_toa_resample)
# L2TOA has less band than L1 so extract
tmp_toa_roi = os.path.join(
working_dir, "L2TOAImageList_{}.tif".format(curL1Res))
l2toa_roi_app = extract_roi(
app_toa_resample.getoutput().get("out"),
l_l1bandidx,
tmp_toa_roi,
write_output=False)
self._l2toa_pipeline.add_otb_app(l2toa_roi_app)
self._l2toaimagelist.append(l2toa_roi_app.getoutput().get("out"))
def generate_toa_sub_image(self, working):
dtm_coarse = self._dem.ALC
# For each res of the input L1 product
for i, toa in enumerate(self._l1toaimagelist):
# undersampling at L2CoarseResolution
toa_sub_image = os.path.join(working, "aot_sub_{}.tif".format(i))
app_resample = resample(toa,
dtm_coarse,
toa_sub_image,
OtbResampleType.LINEAR_WITH_RADIUS,
write_output=False)
self._toa_sub_pipeline.add_otb_app(app_resample)
self._toasublist.append(app_resample.getoutput().get("out"))
# end res loop
#concat
toa_sub_image = os.path.join(working, "aot_sub.tif")
param_concatenate = {"il": self._toasublist, "out": toa_sub_image}
app_concatenate = OtbAppHandler("ConcatenateDoubleImages",
param_concatenate,
write_output=False)
self._toa_sub_pipeline.add_otb_app(app_concatenate)
#apply edg
#invert EDG for masking
out_edgsub_threshold = os.path.join(working, "edgsubthreshold.tif")
param_edgsub_threshold = {
"im": self._edgsubmask,
"thresholdvalue": self._toathresholdminvalue,
"equalvalue": 1,
"outsidevalue": 0,
"out": out_edgsub_threshold + ":uint8"
}
app_edgsub_threshold = OtbAppHandler("OneBandEqualThreshold",
param_edgsub_threshold,
write_output=False)
self._toa_sub_pipeline.add_otb_app(app_edgsub_threshold)
#apply mask to sub toa
tmp_l2subtoa = os.path.join(working, "toasub.tif")
app_l2subtoa = apply_mask(app_concatenate.getoutput().get("out"),
app_edgsub_threshold.getoutput().get("out"),
self._reall1nodata,
tmp_l2subtoa,
write_output=True)
self._subtoaimage = app_l2subtoa.getoutput().get("out")
self._toa_sub_pipeline.free_otb_app()
def generate_l2_toa_images(self, working_dir):
"""
:return:
"""
l_BandsDefinitions = self._plugin.BandsDefinitions
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
l_NbL2Res = len(l_ListOfL2Resolution)
for l2res in range(l_NbL2Res):
# Current resolution: "R1" or "R2"
curRes = l_ListOfL2Resolution[l2res]
dtm = self._dem.ALTList[l2res]
# Get the list of band of the current resolution
listOfL2Bands = l_BandsDefinitions.get_list_of_l2_band_code(curRes)
nbBand = len(listOfL2Bands)
list_of_image = []
# For each band of the current resolution
for l_StrBandIdL2 in listOfL2Bands:
# Get the L1 band index associated to the L2 band code
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL2)
# Generate the list of L2 TOA images per resolution
toa_l2_image = os.path.join(
working_dir, "aot_l2_{}.tif".format(l_StrBandIdL2))
app = resample(self._toa_scalar_list[l1BandIdx],
dtm,
toa_l2_image,
OtbResampleType.LINEAR_WITH_RADIUS,
write_output=False)
self._toa_pipeline.add_otb_app(app)
list_of_image.append(app.getoutput()["out"])
out_concatenate = os.path.join(
working_dir, "L2TOAImageListVector_" + curRes + ".tif")
param_concatenate = {"il": list_of_image, "out": out_concatenate}
concat_app = OtbAppHandler("ConcatenateDoubleImages",
param_concatenate,
write_output=False)
self._toa_pipeline.add_otb_app(concat_app)
self._l2toaimagelist.append(concat_app.getoutput().get("out"))
def GetViewingGrids(self, band, nbL1Bands, vieHRef, satFilename,
zoneFilenames, nodataFilename, listOfZone,
view_angle_col_step, view_angle_row_step,
viewing_angles_zenith, viewing_angles_azimuth,
working):
LOGGER.debug("GetViewingGrids - Band: " + band)
dtm_coarse = self._dem.ALC
l_BandsDefinitions = self._plugin.BandsDefinitions
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(band)
# ---- Viewing angle Grid --------------------------------------------------------------------
l_VieAnglesGridList = []
l_nbDetectors = len(viewing_angles_azimuth)
# Detector loop
LOGGER.debug("For each detectors (nb=%s) ...", l_nbDetectors)
view_resamp_pipeline = OtbPipelineManager()
for detId in range(len(viewing_angles_azimuth)):
# Generate an image with the list of viewing angle values set in the header file
det = listOfZone[detId]
LOGGER.debug("ZenithViewingAngles for band " + band + " and det " +
det + " , nb values: " +
str(len(viewing_angles_zenith[detId])))
LOGGER.debug(viewing_angles_zenith[detId])
LOGGER.debug("AzimuthViewingAngles " + band + " and det " + det +
" nb values: " +
str(len(viewing_angles_azimuth[detId])))
LOGGER.debug(viewing_angles_azimuth[detId])
output_filename = "/tmp/internal_angles_test_{}_{}.xml".format(
band, det)
LOGGER.debug("Angles output_filename : %s", output_filename)
writer = MajaInternalXmlInputAngles(viewing_angles_zenith[detId],
viewing_angles_azimuth[detId],
view_angle_col_step,
view_angle_row_step,
output_filename)
writer.write()
if not os.path.exists(output_filename):
raise MajaExceptionPluginSentinel2Muscate(
"File does not exist " + output_filename)
viewing_grid_filename = os.path.join(
working, "viewing_grid_{}_{}.tif".format(det, band))
# angle_list_to_image()
viewing_angle_app = angle_list_to_image(dtm_coarse,
output_filename,
viewing_grid_filename,
extrapolation=False,
write_output=False)
view_resamp_pipeline.add_otb_app(viewing_angle_app)
# Expand at L2Coarse.
viewing_grid_resamp_filename = os.path.join(
working, "viewing_grid_resamp_{}_{}.tif".format(detId, band))
viewing_grid_resamp_app = resample(
viewing_angle_app.getoutput().get("out"),
dtm_coarse,
viewing_grid_resamp_filename,
OtbResampleType.LINEAR,
write_output=False)
view_resamp_pipeline.add_otb_app(viewing_grid_resamp_app)
# add images in a list
l_VieAnglesGridList.append(
viewing_grid_resamp_app.getoutput().get("out"))
# end detector loop
# Generate the angle images using the zone (detector) mask
LOGGER.debug(
"Start ConcatenatePerZoneVectorImageFilter for band id [" + band +
"]...")
# Concatenate all the detectors
viewing_concat_filename = os.path.join(
working, "viewing_concat_{}.tif".format(band))
param_concat_perzone = {
"mask": self._zonemasksublist[l1BandIdx],
"il": l_VieAnglesGridList,
"zonelist": listOfZone,
"out": viewing_concat_filename
}
concat_perzone_app = OtbAppHandler("ConcatenatePerZone",
param_concat_perzone,
write_output=False)
# Multiply by reference altitude
viewing_grid_mult_filename = os.path.join(
working, "viewing_grid_mult_{}.tif".format(band))
param_scaled_solar = {
"im": concat_perzone_app.getoutput().get("out"),
"coef": float(vieHRef),
"out": viewing_grid_mult_filename
}
view_scale_app = OtbAppHandler("MultiplyByScalar",
param_scaled_solar,
write_output=True)
self._vieimagelist.append(view_scale_app.getoutput().get("out"))
l_nbZones = len(listOfZone)
LOGGER.debug("Start Loop for Zone (nb=" + str(l_nbZones) + ")...")
for d in range(l_nbZones):
l_zone = listOfZone[d]
# -----------------------------------------------------------------------------------
# Compute average values of zenithal and azimuthal angles grid per zone (detector in level1B)
# -----------------------------------------------------------------------------------
# VAP Reader connection (from ATB)
tmp_azi = os.path.join(working,
"tmp_azi_{}_{}.tif".format(band, l_zone))
tmp_azi_image = extract_roi(l_VieAnglesGridList[d], [1],
tmp_azi,
write_output=False)
param_stats = {
"im": tmp_azi_image.getoutput().get("out"),
"exclude": 1,
"mask": self._zonemasksublist[l1BandIdx],
"maskforeground": int(l_zone)
}
l2_stat = OtbAppHandler("Stats", param_stats)
azi_mean = l2_stat.getoutput().get("mean")
tmp_zen = os.path.join(working,
"tmp_zen_{}_{}.tif".format(band, l_zone))
tmp_zen_app = extract_roi(l_VieAnglesGridList[d], [0],
tmp_zen,
write_output=False)
param_stats = {
"im": tmp_zen_app.getoutput().get("out"),
"exclude": 1,
"mask": self._zonemasksublist[l1BandIdx],
"maskforeground": int(l_zone)
}
l2_stat = OtbAppHandler("Stats", param_stats)
zen_mean = l2_stat.getoutput().get("mean")
tmp_mean = (zen_mean, azi_mean)
l_ViewingAngleMean = grid_to_angle(tmp_mean)
l_ViewingAngleMeanDeg = (l_ViewingAngleMean[0] * 180.0 / math.pi,
l_ViewingAngleMean[1] * 180.0 / math.pi)
# Add a vector to mean maps
if l_zone not in self._meanZenithMap:
self._meanZenithMap[listOfZone[d]] = []
if l_zone not in self._meanAzimuthMap:
self._meanAzimuthMap[listOfZone[d]] = []
self._meanZenithMap[listOfZone[d]].append(
str(l_ViewingAngleMeanDeg[0]))
self._meanAzimuthMap[listOfZone[d]].append(
str(l_ViewingAngleMeanDeg[1]))
LOGGER.debug(" For BandId[" + str(band) + "], zone [" +
str(listOfZone[d]) + "] . Mean 'GRID View angles'=" +
str(tmp_mean) + " . Mean 'View angles'=" +
str(l_ViewingAngleMean[0]) + ":" +
str(l_ViewingAngleMean[1]) + " rad. ou " +
str(l_ViewingAngleMeanDeg[0]) + ":" +
str(l_ViewingAngleMeanDeg[1]) + " deg.")
LOGGER.debug("Start Loop for Zone done.")
view_resamp_pipeline.free_otb_app()
def generate_mask_rasters(self, satPixFileNames, defectivPixFileNames,
zoneMaskFileNames, noDataMaskFileNames,
p_ListOfTOABandCode, working):
"""
:param satPixFileNames: ListOfStrings
:param defectivPixFileNames: ListOfStrings
:param zoneMaskFileNames: ListOfStrings
:param noDataMaskFileNames: ListOfStrings
:param p_ListOfTOABandCode: ListOfStrings
:param working: string
:return:
"""
# *******************************************************************************************************
# Generate mask rasters by rasterizing the gml mask per L2 resolution per band
# *******************************************************************************************************
LOGGER.info("Starting GenerateMaskRasters")
l_BandsDefinitions = self._plugin.BandsDefinitions
l2Area = None
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
l_NbL2Res = len(l_ListOfL2Resolution)
l_ListOfL1Resolution = l_BandsDefinitions.ListOfL1Resolution # ListOfStrings
l_NbL1Res = len(l_ListOfL1Resolution)
l_NbL1Band = len(defectivPixFileNames)
dtm_coarse = self._dem.ALC
# Set a constant image if the gml masks are empty
tmp_constant_filename = os.path.join(working, "Masks_const.tif")
#constant_image(dtm_coarse, 0, tmp_constant_filename, write_output=True)
# Initialize the L2 Elements
for l2res in range(l_NbL2Res):
self._l2defectmasklist.append([])
self._l2zonemasklist.append([])
self._l2satimagelist.append([])
self._l2dfpimagelist.append(None)
self._l2zoneimagelist.append(None)
# Init the coarse elements
for coarseband in p_ListOfTOABandCode:
self._satmasksublist.append(None)
self._nodatamasksublist.append(None)
self._zonemasksublist.append(None)
self._l2satmasklist.append(None)
# Loop on L1Res
for l1res in range(l_NbL1Res):
# Current resolution: "R1" or "R2" or "R3"
curL1Res = l_ListOfL1Resolution[l1res]
# Get the list of band of the current resolution
listOfL1Bands = l_BandsDefinitions.get_list_of_l1_band_code(
curL1Res)
nbL1Bands = len(listOfL1Bands)
# For each band of the current resolution
l_l2zone_pipeline = OtbPipelineManager()
firstBandIdx = l_BandsDefinitions.get_band_id_in_l1(
listOfL1Bands[-1])
# Verify if we can optimize the work if its the same file for all bands of
# the resolution and if the bands are in correct bit order
l_strDefectFileNameRef = defectivPixFileNames[firstBandIdx]
l_isDefectSameFilesForBands = True
l_strSatFileNameRef = satPixFileNames[firstBandIdx]
l_isSatSameFilesForBands = True
l_strNoDataFileNameRef = noDataMaskFileNames[firstBandIdx]
l_isNoDataSameFilesForBands = True
for l_BandIdxL1 in range(len(listOfL1Bands)):
# Get the L1 band index associated to the L2 band code
l_StrBandIdL1 = listOfL1Bands[l_BandIdxL1]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL1)
# Filenameverify
if l_strDefectFileNameRef != defectivPixFileNames[l1BandIdx]:
l_isDefectSameFilesForBands = False
if l_strSatFileNameRef != satPixFileNames[l1BandIdx]:
l_isSatSameFilesForBands = False
if l_strNoDataFileNameRef != noDataMaskFileNames[l1BandIdx]:
l_isNoDataSameFilesForBands = False
LOGGER.debug("l_isDefectSameFilesForBands = " +
str(l_isDefectSameFilesForBands))
LOGGER.debug("l_isSatSameFilesForBands = " +
str(l_isSatSameFilesForBands))
LOGGER.debug("l_isNoDataSameFilesForBands = " +
str(l_isSatSameFilesForBands))
# Defective PIX (only in L2 resolution)
if l_isDefectSameFilesForBands:
if curL1Res in l_ListOfL2Resolution:
l_StrBandIdL1 = listOfL1Bands[0]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(
l_StrBandIdL1)
LOGGER.debug("l_StrBandIdL1 : ")
LOGGER.debug(l_StrBandIdL1)
self._l2piximagelist.append(
defectivPixFileNames[l1BandIdx])
dfp_mask = os.path.join(
working, "L1_DFP_Masks_{}.tif".format(curL1Res))
param_bintovec_dfp = {
"im": defectivPixFileNames[l1BandIdx],
"out": dfp_mask + ":uint8",
"nbcomp": nbL1Bands
}
dfp_mask_app = OtbAppHandler("BinaryToVector",
param_bintovec_dfp,
write_output=False)
self._l2_dfp_pipeline.add_otb_app(dfp_mask_app)
self._l2dfpimagelist[l_ListOfL2Resolution.index(
curL1Res)] = dfp_mask_app.getoutput().get("out")
else:
raise MajaExceptionPluginSentinel2Muscate(
"Product format not supported : not the same file for band on PIX"
)
# SAT Mask generation
if l_isSatSameFilesForBands:
# Sat Masks generation
l_StrBandIdL1 = listOfL1Bands[0]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL1)
l_SATFFilename = satPixFileNames[l1BandIdx]
sat_mask = os.path.join(working,
"L1_SAT_Masks_{}.tif".format(curL1Res))
param_bintovec_dfp = {
"im": l_SATFFilename,
"out": sat_mask + ":uint8",
"nbcomp": nbL1Bands
}
sat_mask_app = OtbAppHandler("BinaryToVector",
param_bintovec_dfp,
write_output=True)
# self._l2_sat_pipeline.add_otb_app(sat_mask_app)
if curL1Res in l_ListOfL2Resolution:
self._l2satmasklist[l_ListOfL2Resolution.index(
curL1Res)] = sat_mask_app.getoutput().get("out")
tmp_sat_resample = os.path.join(
working,
"tmp_extract_roi_sat_resample_{}.tif".format(curL1Res))
sat_resamp_app = resample(sat_mask_app.getoutput().get("out"),
dtm_coarse,
tmp_sat_resample,
OtbResampleType.LINEAR,
write_output=False)
self._sub_sat_pipeline.add_otb_app(sat_resamp_app)
for l1band in listOfL1Bands:
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l1band)
tmp_sat_roi = os.path.join(
working, "tmp_extract_roi_sat_{}.tif".format(l1band))
tmp_sat_roi_app = extract_roi(
sat_resamp_app.getoutput().get("out"), [
self.m_headerHandler.get_l1_sat_image_index(
l1BandIdx) - 1
],
tmp_sat_roi,
write_output=False)
self._sub_sat_pipeline.add_otb_app(tmp_sat_roi_app)
self._satmasksublist[
l1BandIdx] = tmp_sat_roi_app.getoutput().get("out")
else:
raise MajaExceptionPluginSentinel2Muscate(
"Product format not supported : not the same file for band on SAT"
)
# No_data mask at L2 coarse
if l_isNoDataSameFilesForBands:
ndt_mask = os.path.join(
working, "L2_NDT_VecMasks_{}.tif".format(curL1Res))
l_StrBandIdL1 = listOfL1Bands[0]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL1)
l_NoDataFilename = noDataMaskFileNames[l1BandIdx]
param_bintovec_ndt = {
"im": l_NoDataFilename,
"out": ndt_mask + ":uint8",
"nbcomp": nbL1Bands
}
ndt_mask_app = OtbAppHandler("BinaryToVector",
param_bintovec_ndt,
write_output=False)
self._subedg_pipeline.add_otb_app(ndt_mask_app)
tmp_ndt_resample = os.path.join(
working,
"tmp_extract_roi_ndt_resample_{}.tif".format(curL1Res))
ndt_resamp_app = resample(ndt_mask_app.getoutput().get("out"),
dtm_coarse,
tmp_ndt_resample,
OtbResampleType.LINEAR,
write_output=False)
self._subedg_pipeline.add_otb_app(ndt_resamp_app)
for l1band in listOfL1Bands:
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l1band)
tmp_ndt_roi = os.path.join(
working, "tmp_extract_roi_ndt_{}.tif".format(l1band))
tmp_ndt_roi_app = extract_roi(
ndt_resamp_app.getoutput().get("out"), [
self.m_headerHandler.get_l1_ndt_image_index(
l1BandIdx) - 1
],
tmp_ndt_roi,
write_output=False)
self._subedg_pipeline.add_otb_app(tmp_ndt_roi_app)
self._nodatamasksublist[
l1BandIdx] = tmp_ndt_roi_app.getoutput().get("out")
else:
raise MajaExceptionPluginSentinel2Muscate(
"Product format not supported : not the same file for band on NoData"
)
# Detectors FootPrint Masks Generation
# Get all the detectors files realted to this resolution
# Test if they all refers to the same files
tmp_res_det_filenames = None
all_same_det_for_bands = True
for l_BandIdxL1 in range(len(listOfL1Bands)):
# Get the L1 band index associated to the L2 band code
l_StrBandIdL1 = listOfL1Bands[l_BandIdxL1]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL1)
LOGGER.debug(
"Sentinel2MuscateL1ImageFileReader::GenerateMaskRasters: CurrentResol = %s, reading the "
"BandId L1 (associated) <%s> with index <%s>.", curL1Res,
l_StrBandIdL1, l1BandIdx)
# Detectors FootPrint Masks
l_bandDetFnames = zoneMaskFileNames[l1BandIdx]
if tmp_res_det_filenames is not None:
if len(tmp_res_det_filenames) != len(l_bandDetFnames):
all_same_det_for_bands = False
break
else:
tmp_res_det_filenames = l_bandDetFnames
#Construct file and det number list
tmp_list_of_detf_filenames = []
tmp_list_of_detf_num = []
tmp_list_of_band_idx = []
if all_same_det_for_bands:
l_ListOfZone = self.m_headerHandler.get_list_of_zones(
listOfL1Bands[0])
nbDetector = len(l_ListOfZone)
# For each detector of the current band
for det in range(nbDetector):
tmp_list_of_detf_filenames.append(
tmp_res_det_filenames[l_ListOfZone[det]])
tmp_list_of_detf_num.append(str(int(l_ListOfZone[det])))
else:
#some bands are not in all det rare case
tmp_det_info_map = {}
for l_BandIdxL1 in range(len(listOfL1Bands)):
# Get the L1 band index associated to the L2 band code
l_StrBandIdL1 = listOfL1Bands[l_BandIdxL1]
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(
l_StrBandIdL1)
LOGGER.debug(
"Sentinel2MuscateL1ImageFileReader::GenerateMaskRasters: CurrentResol = %s, reading the "
"BandId L1 (associated) <%s> with index <%s>.",
curL1Res, l_StrBandIdL1, l1BandIdx)
# Detectors FootPrint Masks
l_bandDetFnames = zoneMaskFileNames[l1BandIdx]
l_ListOfZone = self.m_headerHandler.get_list_of_zones(
l_StrBandIdL1)
nbDetector = len(l_ListOfZone)
# For each detector of the current band
for det in range(nbDetector):
det_num = l_ListOfZone[det]
if det_num not in tmp_det_info_map.keys():
tmp_det_info_map[det_num] = (
zoneMaskFileNames[l1BandIdx][det_num],
[0] * len(listOfL1Bands))
tmp_det_info_map[det_num][1][l_BandIdxL1] = \
self.m_headerHandler.get_l1_dtf_image_index(l1BandIdx, det_num)[0]
#once the info map is done
for det in tmp_det_info_map.keys():
det_info = tmp_det_info_map[det]
tmp_list_of_detf_filenames.append(det_info[0])
tmp_list_of_detf_num.append(str(int(det)))
for x in det_info[1]:
tmp_list_of_band_idx.append(str(x))
#create params
detf_mask = os.path.join(working,
"L1_DETF_Masks_{}.tif".format(curL1Res))
param_dispacth_zone = {
"il": tmp_list_of_detf_filenames,
"out": detf_mask + ':uint8',
"nbcomp": len(listOfL1Bands),
"outvals": tmp_list_of_detf_num
}
#handle not all det/band case
if not all_same_det_for_bands:
param_dispacth_zone["outindexes"] = tmp_list_of_band_idx
#Call the app
dispatch_app = OtbAppHandler("DispatchZonesToVector",
param_dispacth_zone,
write_output=True)
#This is the L2 output
if curL1Res in l_ListOfL2Resolution:
self._l2zoneimagelist[l_ListOfL2Resolution.index(
curL1Res)] = dispatch_app.getoutput().get("out")
#extract the coarse bands
for l1band in listOfL1Bands:
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l1band)
tmp_zone_roi = os.path.join(
working, "tmp_extract_roi_ndt_{}.tif".format(l1band))
tmp_zone_roi_app = extract_roi(
dispatch_app.getoutput().get("out"), [
self.m_headerHandler.get_l1_ndt_image_index(l1BandIdx)
- 1
],
tmp_zone_roi,
write_output=False)
self._subedg_pipeline.add_otb_app(tmp_zone_roi_app)
tmp_zone_with_nodata = os.path.join(
working, "tmp_zone_with_nodata_{}".format(curL1Res))
masterExpr = "( im1b1 > 0 ) ? im1b1 : -10000"
param_bandmath_zone = {
"il": [tmp_zone_roi_app.getoutput().get("out")],
"exp": masterExpr,
"out": tmp_zone_with_nodata
}
zone_thresh_bandmath_app = OtbAppHandler("BandMathDouble",
param_bandmath_zone,
write_output=False)
# LAIG-FA-MAC-1652-CNES : probleme reech detecteur en unsigned char : detecteur 1 devient 0.....
tmp_zone_resample = os.path.join(
working,
"tmp_extract_roi_zone_resample_{}.tif".format(l1BandIdx))
zone_resample_app = resample(
zone_thresh_bandmath_app.getoutput().get("out"),
dtm_coarse,
tmp_zone_resample,
OtbResampleType.LINEAR,
write_output=False)
# threshold everything negative to 0
Thresholdexpr = "im1b1 > 0 ? im1b1 : 0"
tmp_zone_threshold = os.path.join(
working, "tmp_zone_threshold_{}".format(l1BandIdx))
param_bandmath_zone_threshold = {
"il": [zone_resample_app.getoutput().get("out")],
"exp": Thresholdexpr,
"out": tmp_zone_threshold
}
zone_bandmath_threshold_app = OtbAppHandler(
"BandMathDouble",
param_bandmath_zone_threshold,
write_output=False)
# Rounding
tmp_zone_round = os.path.join(
working, "tmp_zone_round_{}".format(l1BandIdx))
param_bandmath_zone_round = {
"im": zone_bandmath_threshold_app.getoutput().get("out"),
"out": tmp_zone_round
}
zone_round_app = OtbAppHandler("RoundImage",
param_bandmath_zone_round,
write_output=True)
# Add to the official output
self._zonemasksublist[l1BandIdx] = zone_round_app.getoutput(
).get("out")
# Log current loop
LOGGER.debug("band loop: " + str(l1BandIdx + 1) + " / " +
str(nbL1Bands) + " (" + curL1Res + ")")
# band loop
LOGGER.debug("band loop: END")
self._l2_detf_pipeline.free_otb_app()
def generate_sol1_image(self, sol_h1, working_dir):
LOGGER.debug("VenusMuscateL1ImageFileReader::GenerateSOL1Image()")
# SOL1 image pipeline connection
# *********************************************************************************************************
LOGGER.debug("MuscateL1ImageFileReader::GenerateSOL1Image()")
l_SOL1_DX_ImageFileName = self._header_handler.get_sol_image_filename(
sol_h1, "DX")
LOGGER.debug("l_SOL1_DX_ImageFileName :" + l_SOL1_DX_ImageFileName)
l_SOL1_DY_ImageFileName = self._header_handler.get_sol_image_filename(
sol_h1, "DY")
LOGGER.debug("l_SOL1_DY_ImageFileName :" + l_SOL1_DY_ImageFileName)
# SOL1 image pipeline connection
# *********************************************************************************************************
# Read the vector images containing the SOL DX and DY
# Extract the corresponding channels since it is vector images
m_SOL1ExtractDXChannel = self._header_handler.get_sol_image_index(
sol_h1, "DX")[0]
# --------------------------------------
# Transform the image coordinates in ground coordinates by multiplying by the L1 product spacing (spec : ImageToGround)
# All viewing and solar angles are transformed in ground coordinates
sol1_mult_DX_filename = os.path.join(working_dir, "sol1_mult_DX.tif")
sol1_mult_DX_app = band_math([l_SOL1_DX_ImageFileName],
"im1b" + str(m_SOL1ExtractDXChannel) +
"*" +
str(self._dem.L2Areas[0].spacing[0]),
sol1_mult_DX_filename + ":double",
write_output=False)
# DY Stuff
m_SOL1ExtractDYChannel = self._header_handler.get_sol_image_index(
sol_h1, "DY")[0]
# --------------------------------------
# Transform the image coordinates in ground coordinates by multiplying by the L1 product spacing (spec : ImageToGround)
# All viewing and solar angles are transformed in ground coordinates
# x(-1) if the spacing Y is negative
sol1_mult_DY_filename = os.path.join(working_dir, "sol1_mult_DY.tif")
sol1_mult_DY_app = band_math([l_SOL1_DY_ImageFileName],
"im1b" + str(m_SOL1ExtractDYChannel) +
"* -1.0 *" +
str(self._dem.L2Areas[0].spacing[1]),
sol1_mult_DY_filename + ":double",
write_output=False)
# Concatenate DX and DY
out_concatenate = os.path.join(working_dir, "sol1_concat.tif")
param_concatenate = {
"il": [
sol1_mult_DX_app.getoutput().get("out"),
sol1_mult_DY_app.getoutput().get("out")
],
"out":
out_concatenate
}
concat_app = OtbAppHandler("ConcatenateDoubleImages",
param_concatenate,
write_output=False)
# Resample the SOL images
out_resample = os.path.join(working_dir, "sol1_concat_resamp.tif")
resamp_app = resample(concat_app.getoutput().get("out"),
self._dem.ALC,
out_resample,
OtbResampleType.LINEAR,
padradius=4,
write_output=True)
# , 0 /* edgePaddingValue */)
# V 4.2 - ITK4 m_SOL1Expand->SetEdgePaddingValue(0)
# Par defaut le filtre initialise le pixel a zero
self._sol1image = resamp_app.getoutput().get("out")
def generate_vie_image(self, view_href, working_dir):
LOGGER.debug("VenusMuscateL1ImageFileReader::GenerateVIEImage()")
# *********************************************************************************************************
# VIE image pipeline connection
# Get the VIE filename from the muscate xml
l_D01_DX_ImageFileName = self._header_handler.get_vie_image_filename(
"01", "DX")
LOGGER.debug(l_D01_DX_ImageFileName)
l_D01_DY_ImageFileName = self._header_handler.get_vie_image_filename(
"01", "DY")
LOGGER.debug(l_D01_DY_ImageFileName)
l_D04_DX_ImageFileName = self._header_handler.get_vie_image_filename(
"04", "DX")
LOGGER.debug(l_D04_DX_ImageFileName)
l_D04_DY_ImageFileName = self._header_handler.get_vie_image_filename(
"04", "DY")
LOGGER.debug(l_D04_DY_ImageFileName)
# --------------------------------------
# VIE Expand image to the L2 Coarse resolution
# Multiply by spacing since it is in m/m
vie5b1_mult_filename = os.path.join(working_dir, "vie5b1_mult.tif")
vie5b1_mult_app = multiply_by_scalar(l_D01_DX_ImageFileName,
self._dem.L2Areas[0].spacing[0],
vie5b1_mult_filename,
write_output=False)
vie5b2_mult_filename = os.path.join(working_dir, "vie5b1_mult_DX.tif")
vie5b2_mult_app = multiply_by_scalar(l_D01_DY_ImageFileName,
-1 *
self._dem.L2Areas[0].spacing[1],
vie5b2_mult_filename,
write_output=False)
vie6b1_mult_filename = os.path.join(working_dir, "vie6b1_mult.tif")
vie6b1_mult_app = multiply_by_scalar(l_D04_DX_ImageFileName,
self._dem.L2Areas[0].spacing[0],
vie6b1_mult_filename,
write_output=False)
vie6b2_mult_filename = os.path.join(working_dir, "vie6b1_mult_DX.tif")
vie6b2_mult_app = multiply_by_scalar(l_D04_DY_ImageFileName,
-1 *
self._dem.L2Areas[0].spacing[1],
vie6b2_mult_filename,
write_output=False)
# Concatenate to get the final VIE
out_concatenate = os.path.join(working_dir, "vie_concat.tif")
param_concatenate = {
"il": [
vie5b1_mult_app.getoutput().get("out"),
vie5b2_mult_app.getoutput().get("out"),
vie6b1_mult_app.getoutput().get("out"),
vie6b2_mult_app.getoutput().get("out")
],
"out":
out_concatenate
}
concat_app = OtbAppHandler("ConcatenateDoubleImages",
param_concatenate,
write_output=False)
LOGGER.debug("Start DTMVIEExpand ...")
out_resample = os.path.join(working_dir, "vie_concat_resamp.tif")
resamp_app = resample(concat_app.getoutput().get("out"),
self._dem.ALC,
out_resample,
OtbResampleType.LINEAR,
padradius=4,
write_output=True)
LOGGER.debug("DTMVIEExpand Done")
self._vieimagelist.append(resamp_app.getoutput().get("out"))
# *********************************************************************************************************
# VIE SHAD image pipeline connection
# *********************************************************************************************************
out_shad_concatenate = os.path.join(working_dir, "vie_concat.tif")
param_shad_concatenate = {
"il": [l_D01_DX_ImageFileName, l_D01_DY_ImageFileName],
"out": out_shad_concatenate
}
concat_shad_app = OtbAppHandler("ConcatenateDoubleImages",
param_shad_concatenate,
write_output=False)
LOGGER.debug("Start DTMSHADExpand ...")
out_shad_resample = os.path.join(working_dir,
"vieshadconcat_resamp.tif")
resamp_shad_app = resample(concat_shad_app.getoutput().get("out"),
self._dem.ALC,
out_shad_resample,
OtbResampleType.LINEAR,
padradius=4,
write_output=True)
LOGGER.debug("DTMSHADExpand Done")
self._vieimagelist.append(resamp_shad_app.getoutput().get("out"))
def run(self, dict_of_input, dict_of_output):
LOGGER.info("Cloud mask resampling start")
p_working = dict_of_input.get("AppHandler").get_directory_manager().get_temporary_directory("CloudMaskResampling_",
do_always_remove=True)
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
do_write = is_croco_on("cloudmaskresampling")
l2_cld_list = []
for p_res in range(0, len(bands_definition.ListOfL2Resolution)):
l_res = bands_definition.ListOfL2Resolution[p_res]
# ---------- Resample All to resolution ---------------
cld_all_resampled = os.path.join(p_working, "cloud_all_" + l_res + ".tif")
cld_all_app = resample(dict_of_output[CLOUD_MASK_ALL], dict_of_input.get("DEM").ALTList[p_res],
cld_all_resampled, OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_all_app)
dict_of_output[CLOUD_MASK_ALL + "_" + l_res] = cld_all_app.getoutput().get("out")
# ---------- Resample All cloud to resolution ---------------
cld_allclouds_resampled = os.path.join(p_working, "cloud_allclouds_" + l_res + ".tif")
cld_allclouds_app = resample(dict_of_output[CLOUD_MASK_ALL_CLOUDS], dict_of_input.get("DEM").ALTList[p_res],
cld_allclouds_resampled, OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_allclouds_app)
dict_of_output[CLOUD_MASK_ALL_CLOUDS + "_" + l_res] = cld_allclouds_app.getoutput().get("out")
# ---------- Resample shadow to resolution ---------------
cld_shadows_resampled = os.path.join(p_working, "cloud_shadows_" + l_res + ".tif")
cld_shadows_app = resample(dict_of_output[CLOUD_MASK_SHADOWS], dict_of_input.get("DEM").ALTList[p_res],
cld_shadows_resampled, OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_shadows_app)
dict_of_output[CLOUD_MASK_SHADOWS + "_" + l_res] = cld_shadows_app.getoutput().get("out")
# ---------- Resample shadvar to resolution ---------------
cld_shadvar_resampled = os.path.join(p_working, "cloud_shadvar_" + l_res + ".tif")
cld_shadvar_app = resample(dict_of_output[CLOUD_MASK_SHADVAR], dict_of_input.get("DEM").ALTList[p_res],
cld_shadvar_resampled, OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_shadvar_app)
dict_of_output[CLOUD_MASK_SHADVAR + "_" + l_res] = cld_shadvar_app.getoutput().get("out")
# ---------- Resample Refl cloud to resolution ---------------
cld_refl_resampled = os.path.join(p_working, "cloud_refl_" + l_res + ".tif")
cld_refl_app = resample(dict_of_output[CLOUD_MASK_REFL], dict_of_input.get("DEM").ALTList[p_res], cld_refl_resampled,
OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_refl_app)
dict_of_output[CLOUD_MASK_REFL + "_" + l_res] = cld_refl_app.getoutput().get("out")
# ---------- Resample ReflVar cloud to resolution ---------------
cld_reflvar_resampled = os.path.join(p_working, "cloud_reflvar_" + l_res + ".tif")
cld_reflvar_app = resample(dict_of_output[CLOUD_MASK_REFL_VAR], dict_of_input.get("DEM").ALTList[p_res],
cld_reflvar_resampled,
OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_reflvar_app)
dict_of_output[CLOUD_MASK_REFL_VAR + "_" + l_res] = cld_reflvar_app.getoutput().get("out")
# ---------- Resample Extension cloud to resolution ---------------
cld_ext_resampled = os.path.join(p_working, "cloud_ext_" + l_res + ".tif")
cld_ext_app = resample(dict_of_output[CLOUD_MASK_EXTENSION], dict_of_input.get("DEM").ALTList[p_res], cld_ext_resampled,
OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_ext_app)
dict_of_output[CLOUD_MASK_EXTENSION + "_" + l_res] = cld_ext_app.getoutput().get("out")
# ---------- Resample Alt to resolution ---------------
cld_alt_resampled = os.path.join(p_working, "cloud_alt_" + l_res + ".tif")
cld_alt_app = resample(dict_of_output[CLOUD_MASK_ALT], dict_of_input.get("DEM").ALTList[p_res], cld_alt_resampled,
OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_alt_app)
dict_of_output[CLOUD_MASK_ALT + "_" + l_res] = cld_alt_app.getoutput().get("out")
# ---------- Resample Cirrus cloud to resolution ---------------
cld_cirrus_resampled = os.path.join(p_working, "cloud_cirrus_" + l_res + ".tif")
cld_cirrus_app = resample(dict_of_output[CLOUD_MASK_CIRRUS], dict_of_input.get("DEM").ALTList[p_res], cld_cirrus_resampled,
OtbResampleType.LINEAR,threshold=0.25,write_output=do_write)
self._apps.add_otb_app(cld_cirrus_app)
dict_of_output[CLOUD_MASK_CIRRUS + "_" + l_res] = cld_cirrus_app.getoutput().get("out")
# APRES MEMORY IN CHAIN CORE ALGORITHMS : V 4-1-0
# Bit 1 - Cloud_Mask.all : summary Logical or of All cloud, extension and shadow masks
# Bit 2 - Cloud_Mask.all clouds: Logical or of All cloud masks and extension
# Bit 3 - Cloud_Mask.shadows : shadows mask from clouds within image
# Bit 4 - Cloud_Mask.shadvar: shadows mask from clouds outside image bit 1 : Cloud_Mask.all
# Bit 5 - Cloud_Mask.refl : reflectance threshold
# Bit 6 - Cloud_Mask.refl_var : reflectance variation threshold
# Bit 7 - Cloud_Mask.extension : extension of the cloud mask
# Bit 8 - Cloud_Mask.alt : stereoscopic mask => VENUS et vide pour les autres
# Bit 9 - Cirrus : Pour L8 et S2 et vide pour les autres
# FORMAT DISK
# Bit 1 - Cloud_Mask.all : summary Logical or of All cloud and shadow masks
# Bit 2 - Cloud_Mask.all clouds: Logical or of All cloud masks
# Bit 3 - Cloud_Mask.shadows : shadows mask from clouds within image
# Bit 4 - Cloud_Mask.shadvar: shadows mask from clouds outside image bit 1 : Cloud_Mask.all
# Bit 5 - Cloud_Mask.refl : reflectance threshold
# Bit 6 - Cloud_Mask.refl_var : reflectance variation threshold
# Bit 7 - Cloud_Mask.extension : extension of the cloud mask
# Bit 8 - VENUS : Cloud_Mask.alt : stereoscopic mask
# Bit 8 - L8 et S2 : Bit 9 - Cirrus
# Bit 8 - Vide pour les autres
cld_list = []
cld_list.append(dict_of_output[CLOUD_MASK_ALL + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_ALL_CLOUDS + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_SHADOWS + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_SHADVAR + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_REFL + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_REFL_VAR + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_EXTENSION + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_ALT + "_" + l_res])
cld_list.append(dict_of_output[CLOUD_MASK_CIRRUS + "_" + l_res])
l2_cld_list.append(cld_list)
dict_of_output["L2CLDList"] = l2_cld_list
def get_viewing_grids(self, band, l2CoarseArea, projectionRef, vieHRef,
satFilename, zoneFilename, nodataFilename,
listOfZone, boundingBox, viewing_angles,
gdalRasterizeMaskCmd, gdalRasterizeDetCmd,
gdalRasterizeNdtCmd, nbCoarseBands, working):
"""
:param band: int
:param l2CoarseArea: AreaType
:param projectionRef: string
:param vieHRef: double
:param satFilename: string
:param zoneFilename: string
:param nodataFilename: string
:param listOfZone: ListOfUIntegers
:param boundingBox: BoundingBoxType
:param viewing_angles:
:param gdalRasterizeMaskCmd: string
:param gdalRasterizeDetCmd: string
:param gdalRasterizeNdtCmd: string
:return:
"""
dtm_coarse = self._dem.ALC
# Set a constant image if the gml masks are empty
tmp_constant_filename = os.path.join(working, "Masks_sat_const.tif")
constant_image(dtm_coarse,
0,
tmp_constant_filename + ":uint8",
write_output=True)
# -----------------------------------------------------------------------------------
# Rasterize all the gml maks at L2 coarse resolution
# to generate the viewing grids
# -----------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------
# Detectors FootPrint
# check if the gml mask contains features
count = self.get_mask_feature_count(zoneFilename)
if count > 0:
# Get the shift between the detector index and the feature index
shift_res = self.get_detfoo_index_shift(zoneFilename)
if shift_res[0]:
l_image_raster_filename = os.path.join(
working, "SubZoneMask_band_id_{}.tif".format(band))
# Additional parameters of the gdal_rasterize system command
sqlRequest = gdalRasterizeDetCmd + \
"-a fid2 -sql 'select fid + {} as fid2, * from MaskFeature'".format(shift_res[1])
GdalRasterize().internal_rasterize_gml_macro(
zoneFilename, boundingBox.xmin, boundingBox.ymin,
boundingBox.xmax, boundingBox.ymax, l2CoarseArea.size[0],
l2CoarseArea.size[1], projectionRef,
l_image_raster_filename, sqlRequest)
submask_resamp_filename = os.path.join(
working,
"SubZoneMask_resampled_band_id_{}.tif".format(band))
resample(l_image_raster_filename, dtm_coarse,
submask_resamp_filename, OtbResampleType.LINEAR)
self._zonemasksublist.append(submask_resamp_filename)
else:
LOGGER.debug("Bad Order DETFOO detected")
l_image_raster_filename = os.path.join(
working, "SubZoneMask_band_id_{}.tif".format(band))
# Additional parameters of the gdal_rasterize system command
sqlRequest = gdalRasterizeDetCmd + \
"-a fid2 -sql 'select fid + 1 as fid2, * from MaskFeature'"
GdalRasterize().internal_rasterize_gml_macro(
zoneFilename, boundingBox.xmin, boundingBox.ymin,
boundingBox.xmax, boundingBox.ymax, l2CoarseArea.size[0],
l2CoarseArea.size[1], projectionRef,
l_image_raster_filename, sqlRequest)
l_fid_dets = self.get_detfoo_index_detector_list(
zoneFilename, 1)
l_image_changed_filename = os.path.join(
working, "SubZoneMaskChanged_band_id_{}.tif".format(band))
change_values_param = {
"im": l_image_raster_filename,
"out": l_image_changed_filename + ":uint8",
"invals": [str(a) for a in l_fid_dets.keys()],
"outvals": [str(a) for a in l_fid_dets.values()]
}
change_values_app = OtbAppHandler("ChangeValues",
change_values_param)
submask_resamp_filename = os.path.join(
working,
"SubZoneMask_resampled_band_id_{}.tif".format(band))
resample(change_values_app.getoutput().get("out"), dtm_coarse,
submask_resamp_filename, OtbResampleType.LINEAR)
self._zonemasksublist.append(submask_resamp_filename)
else:
submask_resamp_filename = os.path.join(
working, "SubZoneMask_resampled_band_id_{}.tif".format(band))
resample(tmp_constant_filename, dtm_coarse,
submask_resamp_filename, OtbResampleType.LINEAR)
self._zonemasksublist.append(submask_resamp_filename)
# -----------------------------------------------------------------------------------
# Saturated pixel mask at L2 coarse
count = self.get_mask_feature_count(satFilename)
if count > 0:
l_image_raster_filename = os.path.join(
working, "SubSatMask_band_id_{}.tif".format(band))
GdalRasterize().internal_rasterize_gml_macro(
satFilename, boundingBox.xmin, boundingBox.ymin,
boundingBox.xmax, boundingBox.ymax, l2CoarseArea.size[0],
l2CoarseArea.size[1], projectionRef, l_image_raster_filename,
gdalRasterizeMaskCmd)
self._satmasksublist.append(l_image_raster_filename)
else:
self._satmasksublist.append(tmp_constant_filename)
# -----------------------------------------------------------------------------------
# No_data mask at L2 coarse
count = self.get_mask_feature_count(nodataFilename, "NODATA")
if count > 0:
l_image_raster_filename = os.path.join(
working, "SubNoDataMask_band_id_{}.tif".format(band))
GdalRasterize().internal_rasterize_gml_macro(
nodataFilename, boundingBox.xmin, boundingBox.ymin,
boundingBox.xmax, boundingBox.ymax, l2CoarseArea.size[0],
l2CoarseArea.size[1], projectionRef, l_image_raster_filename,
gdalRasterizeNdtCmd)
self._nodatamasksublist.append(l_image_raster_filename)
else:
self._nodatamasksublist.append(tmp_constant_filename)
l_VieAnglesGridList = []
l_nbDetectors = len(viewing_angles)
# Detector loop
LOGGER.debug("For each detectors (nb=%s) ...", l_nbDetectors)
for angle in viewing_angles:
l_vieAngleFile = angle.write(working)
# ---------------------------------------------------------------------------------
# Generate an image with the list of viewing angle values set in the header file
# ---------------------------------------------------------------------------------
viewing_grid_filename = os.path.join(
working,
"viewing_grid_{}_{}.tif".format(angle.detector_id, band))
# angle_list_to_image()
viewing_angle_app = angle_list_to_image(dtm_coarse,
l_vieAngleFile,
viewing_grid_filename,
write_output=False,
extrapolation=True)
# Expand at L2Coarse.
viewing_grid_resamp_filename = os.path.join(
working,
"viewing_grid_resamp_{}_{}.tif".format(angle.detector_id,
band))
resample(viewing_angle_app.getoutput().get("out"), dtm_coarse,
viewing_grid_resamp_filename, OtbResampleType.LINEAR)
# add images in a list
l_VieAnglesGridList.append(viewing_grid_resamp_filename)
# end detector loop
LOGGER.debug(
"Start ConcatenatePerZoneVectorImageFilter for band id [%s]...",
band)
# -----------------------------------------------------------------------------------
# Generate the angle images using the zone (detector) mask
# -----------------------------------------------------------------------------------
# Concatenate all the detectors
viewing_concat_filename = os.path.join(
working, "viewing_concat_{}.tif".format(band))
param_concat_perzone = {
"mask": self._zonemasksublist[-1],
"il": l_VieAnglesGridList,
"zonelist": listOfZone,
"out": viewing_concat_filename
}
concat_perzone = OtbAppHandler("ConcatenatePerZone",
param_concat_perzone)
# Multiply by reference altitude
viewing_grid_mult_filename = os.path.join(
working, "viewing_grid_mult_{}.tif".format(band))
param_scaled_solar = {
"im": viewing_concat_filename,
"coef": float(vieHRef),
"out": viewing_grid_mult_filename
}
view_scale_app = OtbAppHandler("MultiplyByScalar",
param_scaled_solar,
write_output=True)
self._vieimagelist.append(view_scale_app.getoutput().get("out"))
l_nbZones = len(listOfZone)
LOGGER.debug("Start Loop for Zone (nb=" + str(l_nbZones) + ")...")
for d in range(l_nbZones):
l_zone = listOfZone[d]
# -----------------------------------------------------------------------------------
# Compute average values of zenithal and azimuthal angles grid per zone (detector in level1B)
# -----------------------------------------------------------------------------------
# VAP Reader connection (from ATB)
tmp_azi = os.path.join(working,
"tmp_azi_{}_{}.tif".format(band, l_zone))
tmp_azi_image = extract_roi(l_VieAnglesGridList[d], [1], tmp_azi)
param_stats = {
"im": tmp_azi,
"exclude": 1,
"mask": self._zonemasksublist[band],
"maskforeground": int(l_zone)
}
l2_stat = OtbAppHandler("Stats", param_stats)
azi_mean = l2_stat.getoutput().get("mean")
tmp_zen = os.path.join(working,
"tmp_zen_{}_{}.tif".format(band, l_zone))
tmp_zen_image = extract_roi(l_VieAnglesGridList[d], [0], tmp_zen)
param_stats = {
"im": tmp_zen,
"exclude": 1,
"mask": self._zonemasksublist[band],
"maskforeground": int(l_zone)
}
l2_stat = OtbAppHandler("Stats", param_stats)
zen_mean = l2_stat.getoutput().get("mean")
tmp_mean = (zen_mean, azi_mean)
l_ViewingAngleMean = grid_to_angle(tmp_mean)
l_ViewingAngleMeanDeg = (l_ViewingAngleMean[0] * 180.0 / math.pi,
l_ViewingAngleMean[1] * 180.0 / math.pi)
# Add a vector to mean maps
if l_zone not in self._meanZenithMap:
self._meanZenithMap[listOfZone[d]] = ["0"] * nbCoarseBands
if l_zone not in self._meanAzimuthMap:
self._meanAzimuthMap[listOfZone[d]] = ["0"] * nbCoarseBands
self._meanZenithMap[listOfZone[d]][band] = str(
l_ViewingAngleMeanDeg[0])
self._meanAzimuthMap[listOfZone[d]][band] = str(
l_ViewingAngleMeanDeg[1])
LOGGER.debug(" For BandId[" + str(band) + "], zone [" +
str(listOfZone[d]) + "] . Mean 'GRID View angles'=" +
str(tmp_mean) + " . Mean 'View angles'=" +
str(l_ViewingAngleMean[0]) + ":" +
str(l_ViewingAngleMean[1]) + " rad. ou " +
str(l_ViewingAngleMeanDeg[0]) + ":" +
str(l_ViewingAngleMeanDeg[1]) + " deg.")
LOGGER.debug("Start Loop for Zone done.")
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]
def read_private_images(self, p_L2PrivateImageFilenamesProvider,
p_ReflectanceQuantificationValue, p_PluginBase,
working_dir):
l_NumberOfComponentsPerPixelForPWAAndTWA = len(
p_PluginBase.BandsDefinitions.L2CoarseBandMap)
# *************************************************************************************************************
# Register the Header for the L2 Input image file
# *************************************************************************************************************
l_ReflectanceQuantificationValue = p_ReflectanceQuantificationValue
# Read the list of wavelength of the RTA/RTC and RCR list of bands in the HDR xml header file
l_RTAHeaderFilename = p_L2PrivateImageFilenamesProvider.get_rta_header_filename(
)
l_RTAHandler = HeaderImageEarthExplorerXMLFileHandler(
l_RTAHeaderFilename)
self.ListOfBandTheoreticalWavelengthOfTheReflectancesComposite = l_RTAHandler.get_list_of_band_theoretical_wavelength(
)
# ********************************************************************************************************/
# #* RTA Reader connection */
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - RTA image filename: " +
p_L2PrivateImageFilenamesProvider.get_rta_image_filename() + ".")
tmp_rta_resample = os.path.join(working_dir, "tmp_rta_resample.tif")
app_rta_resample = resample(
p_L2PrivateImageFilenamesProvider.get_rta_image_filename(),
self._dem.ALC,
tmp_rta_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
tmp_rta_scale = os.path.join(working_dir, "tmp_rta_scale.tif")
param_scaled_rta = {
"im": app_rta_resample.getoutput().get("out"),
"coef": l_ReflectanceQuantificationValue,
"out": tmp_rta_scale
}
rta_scal_app = OtbAppHandler("MultiplyByScalar",
param_scaled_rta,
write_output=True)
self._coarse_pipeline.add_otb_app(rta_scal_app)
self._coarse_pipeline.add_otb_app(app_rta_resample)
self.dict_of_vals["RTAImage"] = rta_scal_app.getoutput()["out"]
# ********************************************************************************************************/
# * RTC Reader connection */
# ********************************************************************************************************/
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - RTC image filename: " +
p_L2PrivateImageFilenamesProvider.get_rtc_image_filename() + ".")
tmp_rtc_resample = os.path.join(working_dir, "tmp_rtc_resample.tif")
app_rtc_resample = resample(
p_L2PrivateImageFilenamesProvider.get_rtc_image_filename(),
self._dem.ALC,
tmp_rtc_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
tmp_rtc_scale = os.path.join(working_dir, "tmp_rtc_scale.tif")
param_scaled_rtc = {
"im": app_rtc_resample.getoutput().get("out"),
"coef": l_ReflectanceQuantificationValue,
"out": tmp_rtc_scale
}
rtc_scal_app = OtbAppHandler("MultiplyByScalar",
param_scaled_rtc,
write_output=True)
self._coarse_pipeline.add_otb_app(rtc_scal_app)
self._coarse_pipeline.add_otb_app(app_rtc_resample)
self.dict_of_vals["RTCImage"] = rtc_scal_app.getoutput()["out"]
# ********************************************************************************************************/
# * RCR Reader connection */
# ********************************************************************************************************/
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - RCR image filename: " +
p_L2PrivateImageFilenamesProvider.get_rcr_image_filename() + ".")
tmp_rcr_resample = os.path.join(working_dir, "tmp_rcr_resample.tif")
app_rcr_resample = resample(
p_L2PrivateImageFilenamesProvider.get_rcr_image_filename(),
self._dem.ALC,
tmp_rcr_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
tmp_rcr_scale = os.path.join(working_dir, "tmp_rcr_scale.tif")
param_scaled_rcr = {
"im": app_rcr_resample.getoutput().get("out"),
"coef": l_ReflectanceQuantificationValue,
"out": tmp_rcr_scale
}
rcr_scal_app = OtbAppHandler("MultiplyByScalar",
param_scaled_rcr,
write_output=True)
self._coarse_pipeline.add_otb_app(rcr_scal_app)
self._coarse_pipeline.add_otb_app(app_rcr_resample)
self.dict_of_vals["RCRImage"] = rcr_scal_app.getoutput()["out"]
# ********************************************************************************************************/
# * PXD Reader connection */
# ********************************************************************************************************/
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - PXD image filename: " +
p_L2PrivateImageFilenamesProvider.get_pxd_image_filename() + ".")
tmp_pxd_resample = os.path.join(working_dir, "tmp_pxd_resample.tif")
app_pxd_resample = resample(
p_L2PrivateImageFilenamesProvider.get_pxd_image_filename(),
self._dem.ALC,
tmp_pxd_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=True)
self._coarse_pipeline.add_otb_app(app_pxd_resample)
self.dict_of_vals["PXDImage"] = app_pxd_resample.getoutput().get("out")
# ********************************************************************************************************/
# * WAS Reader connection (WAM product) */
# ********************************************************************************************************/
tmp_was = os.path.join(working_dir, "tmp_was.tif")
was_extr_app = extract_roi(
p_L2PrivateImageFilenamesProvider.get_wam_image_filename(), [0],
tmp_was,
write_output=False)
tmp_was_resample = os.path.join(working_dir, "tmp_was_resample.tif")
app_was_resample = resample(was_extr_app.getoutput().get("out"),
self._dem.ALC,
tmp_was_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=True)
self._coarse_pipeline.add_otb_app(was_extr_app)
self._coarse_pipeline.add_otb_app(app_was_resample)
self.dict_of_vals["WASImage"] = app_was_resample.getoutput()["out"]
# ********************************************************************************************************/
# * PWA Reader connection (WAM product) */
# ********************************************************************************************************/
tmp_pwa = os.path.join(working_dir, "tmp_pwa.tif")
pwa_image_app = extract_roi(
p_L2PrivateImageFilenamesProvider.get_wam_image_filename(), [1],
tmp_pwa + ":uint8",
write_output=False)
self._coarse_pipeline.add_otb_app(pwa_image_app)
tmp_pwa_resample = os.path.join(working_dir, "tmp_pwa_resample.tif")
app_pwa_resample = resample(pwa_image_app.getoutput().get("out"),
self._dem.ALC,
tmp_pwa_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
self._coarse_pipeline.add_otb_app(app_pwa_resample)
tmp_vecpwa = os.path.join(working_dir, "tmp_pwa_vec.tif")
param_binpwa = {
"im": app_pwa_resample.getoutput()["out"],
"out": tmp_vecpwa,
"nbcomp": l_NumberOfComponentsPerPixelForPWAAndTWA
}
binpwa_app = OtbAppHandler("BinaryToVector",
param_binpwa,
write_output=True)
self._coarse_pipeline.add_otb_app(binpwa_app)
self.dict_of_vals["PWAImage"] = binpwa_app.getoutput()["out"]
# ********************************************************************************************************/
# * TWA Reader connection (WAM product) */
# ********************************************************************************************************/
tmp_twa = os.path.join(working_dir, "tmp_twa.tif")
twa_image = extract_roi(
p_L2PrivateImageFilenamesProvider.get_wam_image_filename(), [2],
tmp_twa + ":uint8",
write_output=False)
tmp_twa_resample = os.path.join(working_dir, "tmp_twa_resample.tif")
app_twa_resample = resample(twa_image.getoutput().get("out"),
self._dem.ALC,
tmp_twa_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
self._coarse_pipeline.add_otb_app(app_twa_resample)
tmp_vectwa = os.path.join(working_dir, "tmp_twa_vec.tif")
param_bintwa = {
"im": app_twa_resample.getoutput().get("out"),
"out": tmp_vectwa,
"nbcomp": l_NumberOfComponentsPerPixelForPWAAndTWA
}
bintwa_app = OtbAppHandler("BinaryToVector",
param_bintwa,
write_output=True)
self._coarse_pipeline.add_otb_app(bintwa_app)
self.dict_of_vals["TWAImage"] = bintwa_app.getoutput()["out"]
# ********************************************************************************************************/
# * STO Reader connection */
# ********************************************************************************************************/
l_STOHeaderFilename = p_L2PrivateImageFilenamesProvider.get_sto_header_filename(
)
l_STOHandler = HeaderImageEarthExplorerXMLFileHandler(
l_STOHeaderFilename)
try:
self.STOBandTheoreticalWavelengthIsPresent = (
l_STOHandler.get_theoretical_wavelength() is not None)
self.STOBandTheoreticalWavelengthValue = l_STOHandler.get_theoretical_wavelength(
)
except BaseException:
LOGGER.debug("Could not retrive STO wavelength !!!")
# 4.3: Get the lis of date (in Bands nodes)
self.STOListOfStringDates = l_STOHandler.get_list_of_bands()
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - STO image filename: " +
p_L2PrivateImageFilenamesProvider.get_sto_image_filename() + ".")
tmp_sto_resample = os.path.join(working_dir, "tmp_sto_resample.tif")
app_sto_resample = resample(
p_L2PrivateImageFilenamesProvider.get_sto_image_filename(),
self._dem.ALC,
tmp_sto_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
self._coarse_pipeline.add_otb_app(app_sto_resample)
tmp_sto_scale = os.path.join(working_dir, "tmp_sto_scale.tif")
param_scaled_sto = {
"im": app_sto_resample.getoutput().get("out"),
"coef": l_ReflectanceQuantificationValue,
"out": tmp_sto_scale
}
sto_scal_app = OtbAppHandler("MultiplyByScalar",
param_scaled_sto,
write_output=True)
self._coarse_pipeline.add_otb_app(sto_scal_app)
self.dict_of_vals["STOImage"] = sto_scal_app.getoutput()["out"]
# ********************************************************************************************************/
# * NDT Reader connection */
# ********************************************************************************************************/
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - NDT image filename: " +
p_L2PrivateImageFilenamesProvider.get_ndt_image_filename() + ".")
tmp_ndt_resample = os.path.join(working_dir, "tmp_ndt_resample.tif")
app_ndt_resample = resample(
p_L2PrivateImageFilenamesProvider.get_ndt_image_filename(),
self._dem.ALC,
tmp_ndt_resample,
OtbResampleType.BCO,
padradius=4.0,
threshold=0.25,
write_output=True)
self._coarse_pipeline.add_otb_app(app_ndt_resample)
self.dict_of_vals["NDTImage"] = app_ndt_resample.getoutput().get("out")
# 4-1-0 : HandlingConnectionCLD DM 1039
# #********************************************************************************************************/
# #* CLD sub (summary) Reader connection */
# #********************************************************************************************************/
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - CLD image filename: " +
p_L2PrivateImageFilenamesProvider.get_cld_image_filename() + ".")
# TODO ATTENTION m_CLDSubOutput est la sortie du Reader (donc pas toute le
# s 9 bandes algo, ou laors sortie du m_ReorganizeBinaryCLDSub ??!!!
self.dict_of_vals[
"CLDSubImage"] = p_L2PrivateImageFilenamesProvider.get_cld_image_filename(
)
# MACCS 5.0.0 : DM 982 . Need CLD bands (for example extract Shadow and ShadVar bands in L2CoarseResolution)
# For GetVectorizedCLDImageList method
tmp_cld_vec = os.path.join(working_dir, "tmp_cld_vec.tif")
param_vec_cld = {
"im": p_L2PrivateImageFilenamesProvider.get_cld_image_filename(),
"out": tmp_cld_vec,
"nbcomp": len(p_PluginBase.CLDCoreAlgorithmsMapBand)
}
cld_vec_app = OtbAppHandler("BinaryToVector",
param_vec_cld,
write_output=False)
self._coarse_pipeline.add_otb_app(cld_vec_app)
cld_vec_image = cld_vec_app.getoutput()["out"]
# In this case some cld bits are not available in the data
tmp_cld_zero = os.path.join(working_dir, "tmp_cld_zero.tif")
cld_const_zero_app = None
if len(p_PluginBase.CLDCoreAlgorithmsMapBand) > len(
p_PluginBase.CLDDataBandsSelected):
cld_const_zero_app = constant_image(cld_vec_image,
0,
os.path.join(
working_dir,
"tmp_zero_cld.tif"),
write_output=False)
self._coarse_pipeline.add_otb_app(cld_const_zero_app)
self.dict_of_vals["VectorizedCLDSubOutput"] = {}
for b in list(p_PluginBase.CLDCoreAlgorithmsMapBand.keys()):
if b in p_PluginBase.CLDDataBandsSelected:
tmp_cld_chan = os.path.join(working_dir, "tmp_" + b + ".tif")
chan = p_PluginBase.CLDDataBandsSelected.index(b)
app_extract_cld = extract_roi(cld_vec_image, [chan],
tmp_cld_chan,
write_output=False)
self._coarse_pipeline.add_otb_app(app_extract_cld)
tmp_cld_resample = os.path.join(working_dir,
"tmp_cld_resample.tif")
app_cld_resample = resample(
app_extract_cld.getoutput().get("out"),
self._dem.ALC,
tmp_cld_resample,
OtbResampleType.BCO,
padradius=4.0,
threshold=0.25,
write_output=True)
self._coarse_pipeline.add_otb_app(app_cld_resample)
self.dict_of_vals["VectorizedCLDSubOutput"][
b] = app_cld_resample.getoutput()["out"]
else:
tmp_cld_resample = os.path.join(working_dir,
"tmp_cld_resample.tif")
app_cld_resample = resample(
cld_const_zero_app.getoutput()["out"],
self._dem.ALC,
tmp_cld_resample,
OtbResampleType.BCO,
padradius=4.0,
threshold=0.25,
write_output=True)
self._coarse_pipeline.add_otb_app(app_cld_resample)
self.dict_of_vals["VectorizedCLDSubOutput"][
b] = app_cld_resample.getoutput()["out"]
# *************************************************************************************************************
# Generate a map of LUT containing all TOCR miniLUTs of the L2 product at D-1 (L2inTOCR)
# *************************************************************************************************************
if p_L2PrivateImageFilenamesProvider.get_dealing_ltc():
LOGGER.debug(
"L2ImageFileReaderBase::ReadPrivateImages - Start reading LTC ..."
)
l_Filename = p_L2PrivateImageFilenamesProvider.get_ltc_header_filename(
)
# --------------------------------------------
# Load the XML file
LOGGER.debug(
"L2ImageFileReaderBase::Start loading the LTC header filename <"
+ l_Filename + "> ....")
l_LUTXMLHandler = GippLUTEarthExplorerXMLFileHandler(l_Filename)
self.ListOfBandTheoreticalWavelengthOfTheLTCComposite = \
l_LUTXMLHandler.get_list_of_band_theoretical_wavelength()
# Read the files
l_L2P_LTC_ListOfFilenames = l_LUTXMLHandler.get_list_of_packaged_dbl_files(
True, True)
# convert the lut indexes
new_lut_indexes = IndexesType()
for ind, vals in list(l_LUTXMLHandler.get_lut_indexes().items()):
if ind == "Solar_Zenith_Angle_Indexes":
new_lut_indexes.set_Solar_Zenith_Angle_Indexes(vals)
elif ind == "Relative_Azimuth_Angle_Indexes":
new_lut_indexes.set_Relative_Azimuth_Angle_Indexes(vals)
elif ind == "Altitude_Indexes":
new_lut_indexes.set_Altitude_Indexes(vals)
elif ind == "AOT_Indexes":
new_lut_indexes.set_AOT_Indexes(vals)
elif ind == "TOA_Reflectance_Indexes":
new_lut_indexes.set_TOA_Reflectance_Indexes(vals)
elif ind == "Zenithal_Angle_Indexes":
new_lut_indexes.set_Zenithal_Angle_Indexes(vals)
elif ind == "View_Zenith_Angle_Indexes":
new_lut_indexes.set_View_Zenith_Angle_Indexes(vals)
elif ind == "Reflectance_Ratio_Indexes":
new_lut_indexes.set_Reflectance_Ratio_Indexes(vals)
else:
raise MajaDataException("Unhandled lut index type : " +
ind)
# Initialize the LookUpTable reader
# --------------------------------------------
# Set the list of minilut filenames to the mapReader
l_lutmap = LUTMap()
l_JdayRef = date_utils.get_julianday_as_int(
date_utils.get_datetime_from_yyyymmdd(
p_PluginBase.ReferenceDate))
for f in l_L2P_LTC_ListOfFilenames:
# Generate the LUT Map
# --------------------------------------------
l_jday = maja_utils.get_integer_jday_from_filename(f)
if l_jday < l_JdayRef:
raise MajaDataException(
"Cannot fill the LookUpTable with filename <" + f +
"> detected at Julian Day " + l_jday +
" as it's prior to reference date " +
p_PluginBase.ReferenceDate + " (" + l_JdayRef + ").")
l_jday = int(l_jday - l_JdayRef)
LOGGER.debug("l_jday " + str(l_jday) + " from filename " + f)
LOGGER.debug("l_JDayRef : " + str(l_JdayRef))
# Add cr lut to map
l_listoffile = List_Of_FilesType()
l_listoffile.add_Relative_File_Path("LTC_Lut_" + str(l_jday) +
".mha")
file_utils.copy_file(
f,
os.path.join(working_dir,
"LTC_Lut_" + str(l_jday) + ".mha"))
l_lut = LUT(index=str(l_jday),
Indexes=new_lut_indexes,
List_Of_Files=l_listoffile)
l_lutmap.add_LUT(l_lut)
# Write down the lut map
output = io.StringIO()
output.write('<?xml version="1.0" ?>\n')
l_lutmap.export(output,
0,
name_='LUTMap',
namespacedef_='',
pretty_print=True)
l_lutmap_filename = os.path.join(working_dir, "LTC_LutMap.xml")
with open(l_lutmap_filename, "w") as fh:
fh.write(output.getvalue().replace(" ", " "))
LOGGER.info("Writed new gipp lutmap to " + l_lutmap_filename)
output.close()
self.dict_of_vals["LTCImage"] = l_lutmap_filename
def generate_edg_images(self, working_dir):
dtm_coarse = self._dem.ALC
# One band equal threshold
out_edg = os.path.join(working_dir, "tmp_EDG_oneBandEqual.tif")
param_edg = {
"im": self._l1toaimagelist[0],
"thresholdvalue": self._reall1nodata,
"equalvalue": 255,
"outsidevalue": 0,
"out": out_edg + ":double"
}
onebandequal_app = OtbAppHandler("OneBandEqualThreshold",
param_edg,
write_output=False)
self._edg_pipeline.add_otb_app(onebandequal_app)
# Resample to coarse
LOGGER.debug("Start IPEDGSub.")
tmp_edg_sub_resample = os.path.join(working_dir, "tmp_edg_sub.tif")
edg_sub_resample_app = resample(
onebandequal_app.getoutput().get("out"),
dtm_coarse,
tmp_edg_sub_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
write_output=False)
# Threshold the output
out_sub_edg = os.path.join(working_dir, "IPEDGSubOutput.tif")
param_sub_edg = {
"im": edg_sub_resample_app.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 0,
"outsidevalue": 1,
"out": out_sub_edg + ":uint8"
}
onebandequal_sub_app = OtbAppHandler("OneBandEqualThreshold",
param_sub_edg,
write_output=True)
# Put in internal data
self._edgsubmask = onebandequal_sub_app.getoutput().get("out")
LOGGER.debug("Start IPEDGSub done.")
# *******************************************************************************************************
# L2EDG pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start L2EDG ...")
l_BandsDefinitions = self._plugin.BandsDefinitions
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
# At L2 resolution
l_NbL2Res = len(l_ListOfL2Resolution)
for r in range(l_NbL2Res):
res_str = l_ListOfL2Resolution[r]
# ExpandFilterPointer => PadAndResampleImageFilter => app ressampling
out_ressampling = os.path.join(
working_dir, "IPEDGRealL2_{}.tif".format(res_str))
#threshold to 0.001 has the same result as multiplynig by 1000 and threshold to 1 after
app = resample(self._edgsubmask,
self._dem.ALTList[r],
out_ressampling + ":uint8",
OtbResampleType.LINEAR,
threshold=0.001,
write_output=False)
self._edg_pipeline.add_otb_app(app)
self._l2edgmasklist.append(app.getoutput().get("out"))
def generate_edg_images(self, working_dir):
"""
:param working_dir: Path
:return:
"""
dtm_coarse = self._dem.ALC
# Get the mask filename
edg_mask_filename = self._header_handler.get_designated_fill_mask_filename()
# Resample to coarse
LOGGER.debug("Start IPEDGSub.")
tmp_edg_sub_resample = os.path.join(working_dir, "tmp_edg_sub.tif")
edg_sub_resample_app = resample(edg_mask_filename, dtm_coarse, tmp_edg_sub_resample,
OtbResampleType.LINEAR_WITH_RADIUS, padradius=4.0,write_output=False)
# Threshold the output
out_sub_edg = os.path.join(working_dir, "tmp_edg_sub_oneBandEqual.tif")
param_sub_edg = {"im": edg_sub_resample_app.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 0,
"outsidevalue": 1,
"out": out_sub_edg + ":uint8"
}
onebandequal_sub_app = OtbAppHandler("OneBandEqualThreshold", param_sub_edg)
# Put in internal data
self._edgsubmask = onebandequal_sub_app.getoutput().get("out")
LOGGER.debug("Start IPEDGSub done.")
# *******************************************************************************************************
# L2EDG pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start L2EDG ...")
l_BandsDefinitions = self._plugin.BandsDefinitions
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
# At L2 resolution
l_NbL2Res = len(l_ListOfL2Resolution)
# Set 1000 to edge pixels to identify the pixel contaminated by an edge pixel after resampling
#out_thresh = os.path.join(working_dir, "EDGThreshL2.tif")
#m_L2EDGThresholdApp = binary_threshold(self._edgsubmask,
# lower_threshold=0,
# inside_value=10000,
# outside_value=0,
# output_image=out_thresh + ":double",
# write_output=False) # //l_ThresholdImageFilter
#self._l2edg_pipeline.add_otb_app(m_L2EDGThresholdApp)
for r in range(l_NbL2Res):
res_str = l_ListOfL2Resolution[r]
# ExpandFilterPointer => PadAndResampleImageFilter => app ressampling
out_ressampling = os.path.join(working_dir, "IPEDGRealL2_{}.tif".format(res_str))
l2_edg_resamp_app = resample(self._edgsubmask,
self._dem.ALTList[r], out_ressampling, OtbResampleType.LINEAR,threshold=0.0001)
self._l2edg_pipeline.add_otb_app(l2_edg_resamp_app)
# Set Threshold value to one because the expand filter interpolates values set to 0
# or 1000 in the first threshold and adds systematically CONST_EPSILON to the output value.
#m_L2EDGThresholdImage2_out = os.path.join(working_dir, "IPEDGMaskL2_{}.tif".format(res_str))
#m_L2EDGThresholdApp2 = binary_threshold(l2_edg_resamp_app.getoutput().get("out"),
# lower_threshold=1.,
# inside_value=1,
# outside_value=0,
# output_image=m_L2EDGThresholdImage2_out + ":uint8",
# write_output=False)
#self._l2edg_pipeline.add_otb_app(m_L2EDGThresholdApp2)
self._l2edgmasklist.append(l2_edg_resamp_app.getoutput().get("out"))
def generate_edg_images_from_toa(self, listOfTOAImageFileNames, working):
"""
:param listOfTOAImageFileNames: list
:param working: path
:return:
"""
# Get the number of band with the number of TOA image files set in the input product directory
l_NbBand = len(listOfTOAImageFileNames) # int
# *******************************************************************************************************
# L2SubEDG pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start IPEDGSub")
m_OneBandFilterList = []
m_ResamplingList = []
m_OrFilterList = []
tmp_edg_pipe = OtbPipelineManager()
for i in range(2):
toaFilename = listOfTOAImageFileNames[i]
LOGGER.debug(("toaFilename : ", toaFilename))
out_oneBandValue = os.path.join(working,
"OneBandValue" + str(i) + ".tif")
band_math_OneBand = one_band_equal_value(
self._toa_scalar_list[i],
output_image=out_oneBandValue + ":uint8",
threshold=0.0,
write_output=False)
tmp_edg_pipe.add_otb_app(band_math_OneBand)
m_OneBandFilterList.append(band_math_OneBand.getoutput()["out"])
out_resample = os.path.join(working,
"mask_resample" + str(i) + ".tif")
resample_mask = resample(band_math_OneBand.getoutput()["out"],
self._dem.ALC,
out_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=0.5,
write_output=False)
tmp_edg_pipe.add_otb_app(resample_mask)
m_ResamplingList.append(resample_mask.getoutput()["out"])
for i in range(l_NbBand - 2):
out_oneBandValue = os.path.join(
working, "OneBandValue" + str(i + 2) + ".tif")
band_math_OneBand = one_band_equal_value(
self._toa_scalar_list[i + 2],
output_image=out_oneBandValue + ":uint8",
threshold=0.0,
write_output=False)
tmp_edg_pipe.add_otb_app(band_math_OneBand)
m_OneBandFilterList.append(band_math_OneBand.getoutput()["out"])
out_resample = os.path.join(working,
"mask_resample" + str(i + 2) + ".tif")
resample_mask = resample(band_math_OneBand.getoutput()["out"],
self._dem.ALC,
out_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=0.5,
write_output=False)
tmp_edg_pipe.add_otb_app(resample_mask)
m_ResamplingList.append(resample_mask.getoutput()["out"])
out_concat = os.path.join(working, "ConcatSubEdgOneBand.tif")
param_oneband_concat = {
"il": m_ResamplingList,
"out": out_concat + ":uint8"
}
qoth_concat_app = OtbAppHandler("ConcatenateMaskImages",
param_oneband_concat,
write_output=False)
tmp_edg_pipe.add_otb_app(qoth_concat_app)
out_or0 = os.path.join(working, "MaskOrMask_0.tif")
band_math_or_b1 = one_band_equal_value(
qoth_concat_app.getoutput().get("out"),
output_image=out_or0 + ":uint8",
threshold=1)
self._edgsubmask = band_math_or_b1.getoutput().get("out")
tmp_edg_pipe.add_otb_app(band_math_or_b1)
tmp_edg_pipe.free_otb_app()
LOGGER.debug("End IPEDGSub.")
# *******************************************************************************************************
# L2EDG pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start L2EDG ...")
l_BandsDefinitions = self._plugin.BandsDefinitions
LOGGER.debug("BANDS DEFINITION")
LOGGER.debug(l_BandsDefinitions)
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
# At L2 resolution
l_NbL2Res = len(l_ListOfL2Resolution)
for r in range(l_NbL2Res):
res_str = l_ListOfL2Resolution[r]
# Set the threshold to 0.0.001 so that all pixel above 1/1000 to edge pixels
# to identify the pixel contaminated by an edge pixel after resampling
# ExpandFilterPointer => PadAndResampleImageFilter => app ressampling
out_ressampling = os.path.join(
working, "IPEDGRealL2_{}.tif".format(res_str))
l2edg_resamp_app = resample(
self._edgsubmask,
self._dem.ALTList[r],
out_ressampling + ":uint8",
OtbResampleType.LINEAR,
threshold=0.0,
write_output=(False
or is_croco_on("sentinel2.l1reader.l2edg")))
self._l2edg_pipeline.add_otb_app(l2edg_resamp_app)
self._l2edgmasklist.append(l2edg_resamp_app.getoutput().get("out"))
LOGGER.debug("End L2EDG ...")
def generate_mask_rasters(self, p_ListOfTOABandCode, working):
# Generate mask rasters by rasterizing the gml mask per L2 resolution per band
LOGGER.info("Starting Muscate GenerateMaskRasters")
l_BandsDefinitions = self._plugin.BandsDefinitions
l2Area = None
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
l_NbL2Res = len(l_ListOfL2Resolution)
l_ListOfL1Resolution = l_BandsDefinitions.ListOfL1Resolution # ListOfStrings
l_NbL1Res = len(l_ListOfL1Resolution)
dtm_coarse = self._dem.ALC
# Set a constant image if the gml masks are empty
tmp_constant_filename = os.path.join(working, "Masks_const.tif")
# initialize the L2 Elements
for l2res in range(l_NbL2Res):
self._l2defectmasklist.append([])
self._l2dfpimagelist.append(None)
# Init the coarse elements
for coarseband in p_ListOfTOABandCode:
self._l2satmasklist.append(None)
for l1res in range(l_NbL1Res):
self._satmasksublist.append(None)
# Test if the plugin has PIX and SAT ?
has_pix_masks = False
defectivPixFileNames = []
pix_node = xml_tools.get_only_value(
self._header_handler.root,
"//Mask_List/Mask/Mask_Properties/NATURE[.='Aberrant_Pixels']",
check=True)
if pix_node is not None:
has_pix_masks = True
defectivPixFileNames = self._header_handler.get_list_of_pix_mask_filenames(
)
has_sat_masks = False
satPixFileNames = []
sat_node = xml_tools.get_only_value(
self._header_handler.root,
"//Mask_List/Mask/Mask_Properties/NATURE[.='Saturation']",
check=True)
if sat_node is not None:
has_sat_masks = True
satPixFileNames = self._header_handler.get_list_of_l1_sat_image_filenames(
)
# Loop on L1Res
for l1res in range(l_NbL1Res):
# Current resolution: "R1" or "R2" or "R3"
curL1Res = l_ListOfL1Resolution[l1res]
# Create constant mask if it will be necessary at a time
tmp_constant_coarse_app = None
tmp_constant_L2_app = None
if not has_sat_masks or not has_pix_masks:
tmp_constant_coarse_filename = os.path.join(
working, "Masks_const_.tif")
tmp_constant_coarse_app = constant_image(
dtm_coarse,
0,
tmp_constant_coarse_filename,
write_output=False)
if curL1Res in l_ListOfL2Resolution:
tmp_constant_L2_filename = os.path.join(
working, "Masks_const_.tif")
tmp_constant_L2_app = constant_image(
self._dem.ALTList[l1res],
0,
tmp_constant_L2_filename + ":uint8",
write_output=False)
self._l2_sat_pipeline.add_otb_app(tmp_constant_L2_app)
# Get the list of band of the current resolution
listOfL1Bands = l_BandsDefinitions.get_list_of_l1_band_code(
curL1Res)
nbL1Bands = len(listOfL1Bands)
# For each band of the current resolution
l_l2zone_pipeline = OtbPipelineManager()
firstBandIdx = l_BandsDefinitions.get_band_id_in_l1(
listOfL1Bands[0])
if has_sat_masks:
l_strSatFileNameRef = satPixFileNames[firstBandIdx]
l_isSatSameFilesForBands = True
for l_BandIdxL1 in range(len(listOfL1Bands)):
# Get the L1 band index associated to the L2 band code
l_StrBandIdL1 = listOfL1Bands[l_BandIdxL1]
l1BandIdx = self._header_handler.get_index_of_band_code(
l_StrBandIdL1)
# Filenameverify
LOGGER.debug(l_StrBandIdL1 + " : " + str(l1BandIdx) +
" : " + satPixFileNames[l1BandIdx])
if l_strSatFileNameRef != satPixFileNames[l1BandIdx]:
l_isSatSameFilesForBands = False
LOGGER.debug("l_isSatSameFilesForBands = " +
str(l_isSatSameFilesForBands))
# SAT Mask generation
if l_isSatSameFilesForBands:
# Sat Masks generation
l_StrBandIdL1 = listOfL1Bands[0]
l1BandIdx = self._header_handler.get_index_of_band_code(
l_StrBandIdL1)
l_SATFFilename = satPixFileNames[l1BandIdx]
sat_mask = os.path.join(
working, "L1_SAT_Masks_{}.tif".format(curL1Res))
param_bintovec_dfp = {
"im": l_SATFFilename,
"out": sat_mask,
"nbcomp": nbL1Bands
}
sat_mask_app = OtbAppHandler("BinaryToVector",
param_bintovec_dfp,
write_output=False)
self._satmask_pipeline.add_otb_app(sat_mask_app)
if curL1Res in l_ListOfL2Resolution:
tmp_sat_l2_resample = os.path.join(
working, "tmp_sat_resample_{}.tif".format(l1res))
if l_BandsDefinitions.get_list_of_l1_band_code(curL1Res) != \
l_BandsDefinitions.get_list_of_l2_band_code(curL1Res):
tmp_l2_band_idx_list = []
#Create the list of index to build the current res sat mask
for l2band in l_BandsDefinitions.get_list_of_l2_band_code(
curL1Res):
l2BandIdxInHeader = self._header_handler.get_index_of_band_code(
l2band)
tmp_l2_band_idx_list.append(
self._header_handler.
get_l1_sat_image_index(l2BandIdxInHeader) -
1)
tmp_satmask_roi = os.path.join(
working,
"tmp_sat_extract_{}.tif".format(l1res))
tmp_extract_sat_toi_app = extract_roi(
sat_mask_app.getoutput()["out"],
tmp_l2_band_idx_list,
tmp_satmask_roi,
write_output=False)
self._satmask_pipeline.add_otb_app(
tmp_extract_sat_toi_app)
resamp_l2_app = resample(
tmp_extract_sat_toi_app.getoutput()["out"],
self._dem.ALTList[l1res],
tmp_sat_l2_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=0.5,
padradius=4,
write_output=False)
self._satmask_pipeline.add_otb_app(resamp_l2_app)
self._l2satmasklist[l_ListOfL2Resolution.index(
curL1Res)] = resamp_l2_app.getoutput().get(
"out")
else:
resamp_l2_app = resample(
sat_mask_app.getoutput()["out"],
self._dem.ALTList[l1res],
tmp_sat_l2_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=0.25,
padradius=4,
write_output=False)
self._satmask_pipeline.add_otb_app(resamp_l2_app)
self._l2satmasklist[l_ListOfL2Resolution.index(
curL1Res)] = resamp_l2_app.getoutput()["out"]
tmp_l1_band_idx_list = []
for l1band in listOfL1Bands:
l1BandIdxInHeader = self._header_handler.get_index_of_band_code(
l1band)
tmp_l1_band_idx_list.append(
self._header_handler.get_l1_sat_image_index(
l1BandIdxInHeader) - 1)
tmp_sat_roi = os.path.join(
working, "tmp_l1_extract_roi_sat_{}.tif".format(l1res))
tmp_sat_roi_app = extract_roi(
sat_mask_app.getoutput()["out"],
tmp_l1_band_idx_list,
tmp_sat_roi,
write_output=False)
l_sat_subthresholdvalue = self._GIPPL2COMMHandler.get_value_f(
"SaturationThresholdSub")
tmp_sat_resample = os.path.join(
working,
"tmp_extract_roi_sat_resample_{}.tif".format(l1res))
app_resample = resample(
tmp_sat_roi_app.getoutput().get("out"),
dtm_coarse,
tmp_sat_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=l_sat_subthresholdvalue,
padradius=4,
write_output=True)
self._satmasksublist[l1res] = app_resample.getoutput(
)["out"]
else:
raise MajaExceptionPluginMuscate(
"Product format not supported : not the same file for band on SAT"
)
else:
# No sat available then put constants masks in outout
if curL1Res in l_ListOfL2Resolution:
self._l2satmasklist[l_ListOfL2Resolution.index(
curL1Res)] = tmp_constant_L2_app.getoutput().get("out")
for l1band in listOfL1Bands:
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l1band)
self._satmasksublist[
l1BandIdx] = tmp_constant_coarse_app.getoutput().get(
"out")
# Verify if we can optimize the work if its the same file for all bands of
# the resolution and if the bands are in correct bit order
if has_pix_masks:
l_strDefectFileNameRef = defectivPixFileNames[firstBandIdx]
l_isDefectSameFilesForBands = True
for l_BandIdxL1 in range(len(listOfL1Bands)):
# Get the L1 band index associated to the L2 band code
l_StrBandIdL1 = listOfL1Bands[l_BandIdxL1]
l1BandIdx = self._header_handler.get_index_of_band_code(
l_StrBandIdL1)
# Filenameverify
if l_strDefectFileNameRef != defectivPixFileNames[
l1BandIdx]:
l_isDefectSameFilesForBands = False
LOGGER.debug("l_isDefectSameFilesForBands = " +
str(l_isDefectSameFilesForBands))
# Defective PIX (only in L2 resolution)
if l_isDefectSameFilesForBands:
if curL1Res in l_ListOfL2Resolution:
l_StrBandIdL1 = listOfL1Bands[0]
l1BandIdx = self._header_handler.get_index_of_band_code(
l_StrBandIdL1)
self._l2piximagelist.append(
defectivPixFileNames[l1BandIdx])
dfp_mask = os.path.join(
working, "L1_DFP_Masks_{}.tif".format(curL1Res))
param_bintovec_dfp = {
"im": defectivPixFileNames[l1BandIdx],
"out": dfp_mask,
"nbcomp": nbL1Bands
}
dfp_mask_app = OtbAppHandler("BinaryToVector",
param_bintovec_dfp,
write_output=False)
self._l2_dfp_pipeline.add_otb_app(dfp_mask_app)
tmp_dfp_l2_resample = os.path.join(
working, "tmp_dfp_resample_{}.tif".format(l1res))
resamp_l2_dfp_app = resample(
dfp_mask_app.getoutput().get("out"),
self._dem.ALTList[l1res],
tmp_dfp_l2_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
threshold=0.25,
padradius=4,
write_output=False)
self._l2dfpimagelist[l_ListOfL2Resolution.index(
curL1Res)] = resamp_l2_dfp_app.getoutput().get(
"out")
self._l2_dfp_pipeline.add_otb_app(resamp_l2_dfp_app)
else:
raise MajaExceptionPluginMuscate(
"Product format not supported : not the same file for band on PIX"
)
else:
if curL1Res in l_ListOfL2Resolution:
self._l2dfpimagelist[l_ListOfL2Resolution.index(
curL1Res)] = tmp_constant_L2_app.getoutput().get("out")
self._l2piximagelist.append(
tmp_constant_L2_app.getoutput().get("out"))
def write_public_images(
self,
p_L2ImageFilenamesProvider,
p_ReflectanceQuantificationValue,
p_AOTQuantificationValue,
p_AOTNodataValue,
p_VAPQuantificationValue,
p_VAPNodataValue,
p_CLDDataBandsSelected,
p_CLDCoreAlgorithmsMapBand,
p_WritePublicProduct,
p_EnvCorOption,
working_dir):
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
# IF PUBLIC PART OF L2 PRODUCT IS WRITTEN
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == ==
if p_WritePublicProduct:
l_NumberOfResolutions = len(p_L2ImageFilenamesProvider.get_sre_headers())
LOGGER.debug("L2ImageFileWriterBase::Initialize Number of resolutions: " + str(l_NumberOfResolutions) + ".")
l_BandsDefinitions = self._plugin.BandsDefinitions
l_RedBandId = 0
l_GreenBandId = 0
l_BlueBandId = 0
resol_QLK = 0
l_Resolution = ""
l_BandsDefinitions = self._plugin.BandsDefinitions
l_RedBandId, l_BlueBandId, l_GreenBandId = l_BandsDefinitions.get_l2_information_for_quicklook_band_code(
self._quicklookredbandcode,
self._quicklookgreenbandcode,
self._quicklookbluebandcode,
)
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** *
# ** ** LOOP on RESOLUTION ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
for resol in range(0, l_NumberOfResolutions):
l_StrResolution = l_BandsDefinitions.ListOfL2Resolution[resol]
# --------------------------------------------------------
# L2 area AreaType l_AreaToL2Resolution
l_AreaFile = self._sre_list[resol]
l_ListOfBand = l_BandsDefinitions.get_list_of_l2_band_code(l_StrResolution)
LOGGER.debug("L2ImageFileReader::Gen Public image file for the resolution " + l_StrResolution + ".")
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# Read the Coef apply for SRE and FRE images
LOGGER.info(
"SRE and FRE values multiply by the reflectance quantification value " +
str(p_ReflectanceQuantificationValue) +
".")
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# ** ** PUBLIC DATA ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
#Store image pointer and filename
tmp_l2_filename_list = []
tmp_l2_image_list = []
tmp_l2_pipe = OtbPipelineManager()
# START WRITING SRE Image file DATA
# Caching the SRE image, before computing the QuickLook.
# Create the scalar image filter
sre_filename = p_L2ImageFilenamesProvider.get_sre_filenames()[
resol] + file_utils.get_extended_filename_write_image_file_standard()
param_scaled_sre = {
"im": self._sre_list[resol],
"coef": p_ReflectanceQuantificationValue,
"out": sre_filename+":int16"}
sre_scal_app = OtbAppHandler("MultiplyByScalar", param_scaled_sre,
write_output=is_croco_on("earthexplorer.l2writer.sre"))
tmp_l2_image_list.append(sre_scal_app.getoutput().get("out"))
tmp_l2_filename_list.append(sre_filename)
tmp_l2_pipe.add_otb_app(sre_scal_app)
#QuickLook stuff
if resol == resol_QLK :
tmp_sre_roi_red = os.path.join(working_dir, "tmp_sre_roi_red.tif")
tmp_sre_roi_red_app = extract_roi(self._sre_list[resol], [l_RedBandId],
tmp_sre_roi_red, write_output=is_croco_on("earthexplorer.l2writer.roi"))
tmp_l2_image_list.append(tmp_sre_roi_red_app.getoutput().get("out"))
tmp_l2_filename_list.append(tmp_sre_roi_red)
self._qckl_red_image = tmp_sre_roi_red
tmp_l2_pipe.add_otb_app(tmp_sre_roi_red_app)
tmp_sre_roi_green = os.path.join(working_dir, "tmp_sre_roi_green.tif")
tmp_sre_roi_green_app = extract_roi(self._sre_list[resol], [l_GreenBandId],
tmp_sre_roi_green, write_output=is_croco_on("earthexplorer.l2writer.roi"))
tmp_l2_image_list.append(tmp_sre_roi_green_app.getoutput().get("out"))
tmp_l2_filename_list.append(tmp_sre_roi_green)
self._qckl_green_image = tmp_sre_roi_green
tmp_l2_pipe.add_otb_app(tmp_sre_roi_green_app)
tmp_sre_roi_blue = os.path.join(working_dir, "tmp_sre_roi_blue.tif")
tmp_sre_roi_blue_app = extract_roi(self._sre_list[resol], [l_BlueBandId],
tmp_sre_roi_blue, write_output=is_croco_on("earthexplorer.l2writer.roi"))
tmp_l2_image_list.append(tmp_sre_roi_blue_app.getoutput().get("out"))
tmp_l2_filename_list.append(tmp_sre_roi_blue)
self._qckl_blue_image = tmp_sre_roi_blue
tmp_l2_pipe.add_otb_app(tmp_sre_roi_blue_app)
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# START WRITING FRE Image file DATA
fre_scal_app = None
if p_EnvCorOption:
fre_filename = p_L2ImageFilenamesProvider.get_fre_filenames()[
resol] + file_utils.get_extended_filename_write_image_file_standard()
param_scaled_fre = {
"im": self._fre_list[resol],
"coef": p_ReflectanceQuantificationValue,
"out": fre_filename+":int16"}
fre_scal_app = OtbAppHandler("MultiplyByScalar", param_scaled_fre,
write_output=is_croco_on("earthexplorer.l2writer.fre"))
#Write SRE and FRE simultaneously
tmp_l2_image_list.append(fre_scal_app.getoutput().get("out"))
tmp_l2_filename_list.append(fre_filename)
tmp_l2_pipe.add_otb_app(fre_scal_app)
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# START WRITING ATB Image file DATA
# Initialize the Scalar filter
# FA1424: Temporary Fix to address cosmetic aspects of FA1424
# VAPThreshold.SetInput(self.GetVAPImageList()[resol))
# VAPThreshold.SetOutsideValue(255. / p_VAPQuantificationValue)
# VAPThreshold.ThresholdAbove(255. / p_VAPQuantificationValue)
# VAPScalar.SetInput(VAPThreshold.GetOutput())
# VAPScalar.SetCoef(p_VAPQuantificationValue)
tmp_vap = os.path.join(working_dir, "tmp_vap_scaled_" + l_StrResolution + ".tif")
param_bandmath_vap = {
"il": [
self._l2vapimagelist[resol],
self._l2edgimagelist[resol]],
"exp": "(im2b1 == 1)?" +
str(p_VAPNodataValue) +
":" +
"rint(im1b1*" +
str(p_VAPQuantificationValue)+")",
"out": tmp_vap + ":uint8"}
vap_scal_app = OtbAppHandler("BandMathDouble", param_bandmath_vap, write_output=False)
tmp_aot = os.path.join(working_dir, "tmp_aot_scaled_" + l_StrResolution + ".tif")
param_bandmath_aot = {"il": [self._l2aotlist[resol], self._l2edgimagelist[resol]],
"exp": "(im2b1 == 1)?" + str(p_AOTNodataValue) + ":" + "rint(im1b1*" + str(
p_AOTQuantificationValue)+")",
"out": tmp_aot + ":uint8"
}
aot_scal_app = OtbAppHandler("BandMathDouble", param_bandmath_aot, write_output=False)
tmp_l2_pipe.add_otb_app(aot_scal_app)
atb_filename = p_L2ImageFilenamesProvider.get_atb_image_filename()[resol]
param_atb_concat = {"il": [vap_scal_app.getoutput().get("out"), aot_scal_app.getoutput().get("out")],
"out": atb_filename + ":uint8"
}
atb_concat_app = OtbAppHandler("ConcatenateMaskImages", param_atb_concat,
write_output=is_croco_on("earthexplorer.l2writer.atb"))
tmp_l2_image_list.append(atb_concat_app.getoutput().get("out"))
tmp_l2_filename_list.append(atb_filename)
tmp_l2_pipe.add_otb_app(atb_concat_app)
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# START WRITING MSK Image file DATA
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# Connect the WAM image
was_resampled = os.path.join(working_dir, "was_resampled_" + l_StrResolution + ".tif")
app_resample_was = resample(self._wasimage, self._dtm.ALTList[resol],
was_resampled, threshold=0.25, write_output=False)
tmp_l2_pipe.add_otb_app(app_resample_was)
# Connect the HID image
hid_resampled = os.path.join(working_dir, "hid_resampled_" + l_StrResolution + ".tif")
app_resample_hid = resample(self._dtm_hid, self._dtm.ALTList[resol],
hid_resampled, threshold=0.25, write_output=False)
tmp_l2_pipe.add_otb_app(app_resample_hid)
# Connect the SHDimage
shd_resampled = os.path.join(working_dir, "shd_resampled_" + l_StrResolution + ".tif")
app_resample_shd = resample(self._dtm_shd, self._dtm.ALTList[resol],
shd_resampled, threshold=0.25, write_output=False)
tmp_l2_pipe.add_otb_app(app_resample_shd)
# Create the MOTH image that concatenates the WAT, HID, SHD, STL and TGS masks
MOTHImageList = []
MOTHImageList.append(app_resample_was.getoutput().get("out"))
MOTHImageList.append(app_resample_hid.getoutput().get("out"))
MOTHImageList.append(app_resample_shd.getoutput().get("out"))
# Append STL
MOTHImageList.append(self._stl_list[resol])
# Append TGS
MOTHImageList.append(self._tgs_list[resol])
app_resample_snow = None
if self._cld_snow is not None:
snow_resampled = os.path.join(working_dir, "snow_resampled_" + l_StrResolution + ".tif")
app_resample_snow = resample(self._cld_snow, self._dtm.ALTList[resol],
snow_resampled, working_dir, 0.25, write_output=False)
tmp_l2_pipe.add_otb_app(app_resample_snow)
MOTHImageList.append(app_resample_snow.getoutput().get("out"))
# Concat to get atb
moth_tmp_concat = os.path.join(working_dir, "tmp_moth_" + l_StrResolution + ".tif")
param_moth_concat = {"il": MOTHImageList,
"out": moth_tmp_concat
}
# Concatenate to produce the MOTH file
app_moth_concat = OtbAppHandler("ConcatenateMaskImages", param_moth_concat, write_output=False)
tmp_l2_pipe.add_otb_app(app_moth_concat)
# Binary concatenation of WAT, HID, SHD, STL and TGS masks
msk_filename = p_L2ImageFilenamesProvider.get_msk_filename()[resol]
param_moth_binconcat = {"im": app_moth_concat.getoutput().get("out"),
"out": msk_filename + ":uint8"
}
moth_binconcat_app = OtbAppHandler("BinaryConcatenate", param_moth_binconcat,
write_output=is_croco_on("earthexplorer.l2writer.msk"))
tmp_l2_image_list.append(moth_binconcat_app.getoutput().get("out"))
tmp_l2_filename_list.append(msk_filename)
tmp_l2_pipe.add_otb_app(moth_binconcat_app)
# Concatenation of the MSK mask with the CLD and MOTH masks
# --------------------------------------------------------
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
# START WRITING QLT Image file DATA
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
QOTHImageList = []
QOTHImageList.append(self._l2edgimagelist[resol])
QOTHImageList.append(self._l2taomasklist[resol])
if self._plugin.WaterVapourDetermination:
QOTHImageList.append(self._l2iwcmasklist[resol])
# Concat to get atb
qoth_tmp_concat = os.path.join(working_dir, "tmp_qoth_" + l_StrResolution + ".tif")
param_qoth_concat = {"il": QOTHImageList,
"out": qoth_tmp_concat + ":uint8"
}
qoth_concat_app = OtbAppHandler("ConcatenateImages", param_qoth_concat, write_output=False)
qoth_tmp_binconcat = os.path.join(working_dir, "tmp_binqoth_" + l_StrResolution + ".tif")
param_qoth_binconcat = {"im": qoth_concat_app.getoutput().get("out"),
"out": qoth_tmp_binconcat + ":uint8"
}
qoth_binconcat_app = OtbAppHandler("BinaryConcatenate", param_qoth_binconcat, write_output=False)
# -------------------------------------------------------
# Concatenation of the QLT mask with the SAT, PIX and OTH masks
# --------------------------------------------------------
# As for the PIX mask, the SAT mask in concatenate in one band where each bit matches one band
sat_tmp_concat = os.path.join(working_dir, "tmp_sat_" + l_StrResolution + ".tif")
param_sat_binconcat = {"im": self._l2satimagelist[resol],
"out": sat_tmp_concat + ":uint8"
}
sat_binconcat_app = OtbAppHandler("BinaryConcatenate", param_sat_binconcat, write_output=False)
# Create the QLT vector image
qlt_tmp_concat = os.path.join(working_dir, "tmp_qlt_" + l_StrResolution + ".tif")
QLTImageList = []
QLTImageList.append(sat_binconcat_app.getoutput().get("out"))
QLTImageList.append(self._l2piximagelist[resol])
QLTImageList.append(qoth_binconcat_app.getoutput().get("out"))
param_qlt_concat = {"il": QLTImageList,
"out": qlt_tmp_concat + ":uint8"
}
qlt_concat_app = OtbAppHandler("ConcatenateImages", param_qlt_concat,
write_output=is_croco_on("earthexplorer.l2writer.qlt"))
tmp_l2_image_list.append(qlt_concat_app.getoutput().get("out"))
tmp_l2_filename_list.append(p_L2ImageFilenamesProvider.get_qlt_filenames()[resol])
tmp_l2_pipe.add_otb_app(qlt_concat_app)
# --------------------------
# Write all the images at L2 Reso
write_images(tmp_l2_image_list, tmp_l2_filename_list)
tmp_l2_pipe.free_otb_app()
clean_pipe(self._sre_list[resol])
if p_EnvCorOption:
clean_pipe(self._fre_list[resol])
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** *
# START WRITING CLD Public Image file DATA
# ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** *
# Connect the CLD image
# -------------------------------------
self.write_cld_image(self._l2cldlist[resol], p_CLDDataBandsSelected,
p_L2ImageFilenamesProvider.get_cld_image_filename()[resol])
LOGGER.debug("Writing L2 resolution image done !")
def write_quicklook_image_from_files(
filename,
p_WritePublicProduct,
p_QuicklookRedBandImage,
p_QuicklookGreenBandImage,
p_QuicklookBlueBandImage,
p_QuicklookMinReflRedBand,
p_QuicklookMaxReflRedBand,
p_QuicklookMinReflGreenBand,
p_QuicklookMaxReflGreenBand,
p_QuicklookMinReflBlueBand,
p_QuicklookMaxReflBlueBand,
p_RealL2NoData,
dtm,
working_dir):
# ====================================================================
# IF PUBLIC PART OF L2 PRODUCT IS WRITTEN
# ====================================================================
if p_WritePublicProduct:
LOGGER.debug("Start QLK wiring...")
# Replace NoData value by min
# TODO
# Generate he quicklook
tmp_qlk_red_sub = os.path.join(working_dir, "tmp_qck_red_sub.tif")
tmp_qlk_green_sub = os.path.join(working_dir, "tmp_qck_green_sub.tif")
tmp_qlk_blue_sub = os.path.join(working_dir, "tmp_qck_blue_sub.tif")
# Call the resampling app
resampling_app_red = resample(p_QuicklookRedBandImage, dtm, tmp_qlk_red_sub,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4, outarea=[1000,1000], write_output=False)
resampling_app_green = resample(p_QuicklookGreenBandImage, dtm, tmp_qlk_green_sub,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4, outarea=[1000,1000], write_output=False)
resampling_app_blue = resample(p_QuicklookBlueBandImage, dtm, tmp_qlk_blue_sub,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4, outarea=[1000,1000], write_output=False)
# Concatenate images
tmp_qlk = os.path.join(working_dir, "tmp_qck_sub.tif")
param_concat = {
"il": [
resampling_app_red.getoutput().get("out"),
resampling_app_blue.getoutput().get("out"),
resampling_app_green.getoutput().get("out")],
"out": tmp_qlk,
"ram": str(OtbAppHandler.ram_to_use / 3)
}
concat_app = OtbAppHandler("ConcatenateDoubleImages", param_concat,write_output=True)
# Rescale between 0 and 255
rescale_intensity(
concat_app.getoutput().get("out"),
0,
255,
filename +
file_utils.get_extended_filename_write_image_file_standard()+":uint8",
inmin=[str(p_QuicklookMinReflRedBand), str(p_QuicklookMinReflGreenBand), str(p_QuicklookMinReflBlueBand)],
inmax=[str(p_QuicklookMaxReflRedBand), str(p_QuicklookMaxReflGreenBand), str(p_QuicklookMaxReflBlueBand)]
)
if (os.path.exists(filename + '.aux.xml')):
LOGGER.debug("Removing " + filename + '.aux.xml file')
os.remove(filename + '.aux.xml')
def generate_edg_images(self, working_dir):
"""
:param working_dir: String
:return:
"""
dtm_coarse = self._dem.ALC
list_of_binary_threshold = []
m_OrFilter1List = []
m_OrFilter2List = []
# *******************************************************************************************************
# IPEDGSub pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start IPEDGSub ...")
# At L2 coarse resolution
# Set to 0 the pixel that are not edges in the zone (detector) mask image raster
out_thresh_0 = os.path.join(working_dir, "IPEDGOrFilter1SubMask_0.tif")
out_binary_threshold_ipedg_image_b1 = binary_threshold(
input_image=self._zonemasksublist[0],
inside_value=0,
outside_value=1,
output_image=out_thresh_0 + ":uint8",
lower_threshold=1,
write_output=False)
# Concatenate the zone image and the nodata one
m_OrFilter2List.append(
out_binary_threshold_ipedg_image_b1.getoutput()["out"])
m_OrFilter2List.append(self._nodatamasksublist[0])
l_NbBand = len(self._zonemasksublist)
# band loop
for l_band in range(l_NbBand - 1):
out_thresh_1 = os.path.join(
working_dir,
"IPEDGThreshFilter1SubMask_{}.tif".format(l_band + 1))
out_binary_threshold_ipedg_image = binary_threshold(
input_image=self._zonemasksublist[l_band + 1],
lower_threshold=1,
inside_value=0,
outside_value=1,
output_image=out_thresh_1 + ":uint8",
write_output=False)
self._subedg_pipeline.add_otb_app(out_binary_threshold_ipedg_image)
m_OrFilter2List.append(
out_binary_threshold_ipedg_image.getoutput().get("out"))
m_OrFilter2List.append(self._nodatamasksublist[l_band + 1])
#OR filter
out_edg = os.path.join(working_dir, "IPEDGubMask.tif")
or_edg_sub_app = band_math_or(m_OrFilter2List,
out_edg + ":uint8",
write_output=True)
# Allocation of 7 Go in S2 MUSCATE case
self._edgsubmask = or_edg_sub_app.getoutput().get("out")
self._subedg_pipeline.free_otb_app()
LOGGER.debug("Start IPEDGSub done.")
# *******************************************************************************************************
# L2EDG pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start L2EDG ...")
l_BandsDefinitions = self._plugin.BandsDefinitions
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
# At L2 resolution
l_NbL2Res = len(l_ListOfL2Resolution)
for r in range(l_NbL2Res):
res_str = l_ListOfL2Resolution[r]
# Set 1000 to edge pixels to identify the pixel contaminated by an edge pixel after resampling
out_thresh = os.path.join(working_dir,
"EDGThreshL2_{}.tif".format(res_str))
#m_L2EDGThreshold_app = binary_threshold(self._edgsubmask,
# lower_threshold=0,
# inside_value=0,
# outside_value=1000,
# output_image=out_thresh + ":uint8",
# write_output=False)
#self._pipeline.add_otb_app(m_L2EDGThreshold_app)
# ExpandFilterPointer => PadAndResampleImageFilter => app ressampling
out_ressampling = os.path.join(
working_dir, "IPEDGRealL2_{}.tif".format(res_str))
resamp_app = resample(self._edgsubmask,
self._dem.ALTList[r],
out_ressampling + ":uint8",
OtbResampleType.LINEAR,
threshold=0.000001,
write_output=False)
self._pipeline.add_otb_app(resamp_app)
# Set Threshold value to one because the expand filter interpolates values set to 0
# or 1000 in the first threshold and adds systematically CONST_EPSILON to the output value.
#m_L2EDGThresholdImage2_out = os.path.join(working_dir, "IPEDGMaskL2_{}.tif".format(res_str))
#m_L2EDGThresholdImageApp2 = binary_threshold(
# resamp_app.getoutput().get("out"),
# lower_threshold=0.,
# inside_value=0,
# outside_value=1,
# output_image=m_L2EDGThresholdImage2_out + ":uint8",
# write_output=False)
#self._pipeline.add_otb_app(m_L2EDGThresholdImageApp2)
self._l2edgmasklist.append(resamp_app.getoutput().get("out"))
def write_public_images(self, p_PublicDirectory, p_L2BaseFilename,
p_ReflectanceQuantificationValue,
p_AOTQuantificationValue, p_AOTNodataValue,
p_VAPQuantificationValue, p_VAPNodataValue,
p_CLDDataBandsSelected, p_CLDCoreAlgorithmsMapBand,
p_WritePublicProduct, p_EnvCorOption, working_dir):
# IF PUBLIC PART OF L2 PRODUCT IS WRITTEN
if p_WritePublicProduct:
l_BandsDefinitions = self._plugin.BandsDefinitions
l_ListOfL2Res = l_BandsDefinitions.ListOfL2Resolution
l_NumberOfResolutions = len(l_ListOfL2Res)
LOGGER.debug(
"L2ImageFileWriterBase::Initialize Number of resolutions: " +
str(l_NumberOfResolutions) + ".")
# Not use the list of XS band because for Landsat8, the band B9 is not
# selected in the L2 resolution (only in L2Coarse resolution)
l_BaseL2FullFilename = os.path.join(p_PublicDirectory,
p_L2BaseFilename)
l_MASKSDirectory = os.path.join(p_PublicDirectory, "MASKS")
l_BaseL2FullMASKSFilename = os.path.join(l_MASKSDirectory,
p_L2BaseFilename)
file_utils.create_directory(l_MASKSDirectory)
resol_QLK = 0
l_RedBandId, l_BlueBandId, l_GreenBandId = l_BandsDefinitions.get_l2_information_for_quicklook_band_code(
self._quicklookredbandcode, self._quicklookgreenbandcode,
self._quicklookbluebandcode)
# *************************************************************************************************************
# **** LOOP on RESOLUTION *********************************************
# *************************************************************************************************************
for resol in range(0, l_NumberOfResolutions):
l_StrResolution = l_BandsDefinitions.ListOfL2Resolution[resol]
# --------------------------------------------------------
# L2 area AreaType l_AreaToL2Resolution
l_AreaFile = self._sre_list[resol]
l_ListOfBand = l_BandsDefinitions.get_list_of_l2_band_code(
l_StrResolution)
l_NumberOfBands = len(l_ListOfBand)
LOGGER.debug(
"L2ImageFileReader::Gen Public image file for the resolution "
+ l_StrResolution + ".")
l_grpSuffix = ""
if l_NumberOfResolutions == 1:
l_grpSuffix = "XS"
else:
l_grpSuffix = l_ListOfL2Res[resol]
l_StrResolution = l_BandsDefinitions.ListOfL2Resolution[resol]
# Read the Coef apply for SRE and FRE images
LOGGER.info(
"SRE and FRE values multiply by the reflectance quantification value "
+ str(p_ReflectanceQuantificationValue) + ".")
# *************************************************************************************************************
# **** PUBLIC DATA ************************************************
# *************************************************************************************************************
# START WRITING SRE Image file DATA
# Initialize the Scalar filter
sre_pipeline = OtbPipelineManager()
#Extract each channel for each file
tmp_l2_filename_list = []
tmp_l2_image_list = []
tmp_sre_scaled = os.path.join(
working_dir,
"tmp_sre_multi_round_" + l_StrResolution + ".tif")
param_scaled_sre = {
"im": self._sre_list[resol],
"coef": p_ReflectanceQuantificationValue,
"out": tmp_sre_scaled
}
scaled_sre_app = OtbAppHandler("RoundImage",
param_scaled_sre,
write_output=False)
sre_pipeline.add_otb_app(scaled_sre_app)
for i in range(l_NumberOfBands):
if resol == resol_QLK and (l_RedBandId == i
or l_GreenBandId == i
or l_BlueBandId == i):
tmp_sre_roi = os.path.join(
working_dir,
"tmp_sre_roi_" + l_ListOfBand[i] + ".tif")
tmp_sre_roi_app = extract_roi(self._sre_list[resol],
[i],
tmp_sre_roi,
write_output=False)
tmp_l2_image_list.append(
tmp_sre_roi_app.getoutput().get("out"))
tmp_l2_filename_list.append(tmp_sre_roi)
if l_RedBandId == i:
self._qckl_red_image = tmp_sre_roi
elif l_GreenBandId == i:
self._qckl_green_image = tmp_sre_roi
elif l_BlueBandId == i:
self._qckl_blue_image = tmp_sre_roi
sre_pipeline.add_otb_app(tmp_sre_roi_app)
tmp_sre_scaled_roi = os.path.join(
working_dir,
"tmp_sre_scaled_roi_" + l_ListOfBand[i] + ".tif")
tmp_sre_scaled_roi_app = extract_roi(
scaled_sre_app.getoutput().get("out"), [i],
tmp_sre_scaled_roi + ":int16",
write_output=False)
tmp_l2_image_list.append(
tmp_sre_scaled_roi_app.getoutput().get("out"))
sre_pipeline.add_otb_app(tmp_sre_scaled_roi_app)
tmp_l2_filename_list.append(
l_BaseL2FullFilename + "_SRE_" + l_ListOfBand[i] +
".tif" + file_utils.
get_extended_filename_write_image_file_standard())
# START WRITING FRE Image file DATA
tmp_tgs_filename = os.path.join(
working_dir, "tmp_tgs_" + l_StrResolution + ".tif")
tmp_stl_filename = os.path.join(
working_dir, "tmp_stl_" + l_StrResolution + ".tif")
fre_pipeline = OtbPipelineManager()
if p_EnvCorOption:
# Initialize the Scalar filter
tmp_fre_scaled = os.path.join(
working_dir,
"tmp_fre_multi_round_" + l_StrResolution + ".tif")
param_scaled_fre = {
"im": self._fre_list[resol],
"coef": p_ReflectanceQuantificationValue,
"out": tmp_fre_scaled
}
scaled_fre_app = OtbAppHandler("RoundImage",
param_scaled_fre,
write_output=False)
fre_pipeline.add_otb_app(scaled_fre_app)
# Extract each channel for each file
for i in range(l_NumberOfBands):
tmp_fre_roi = os.path.join(
working_dir,
"tmp_fre_roi_" + l_ListOfBand[i] + ".tif")
tmp_fre_roi_app = extract_roi(
scaled_fre_app.getoutput().get("out"), [i],
tmp_fre_roi + ":int16",
write_output=False)
tmp_l2_image_list.append(
tmp_fre_roi_app.getoutput().get("out"))
fre_pipeline.add_otb_app(tmp_fre_roi_app)
tmp_l2_filename_list.append(
l_BaseL2FullFilename + "_FRE_" + l_ListOfBand[i] +
".tif" + file_utils.
get_extended_filename_write_image_file_standard())
#Add tgs and stl also provided by the envcorr
tmp_l2_image_list.append(self._tgs_list[resol])
tmp_l2_filename_list.append(tmp_tgs_filename)
tmp_l2_image_list.append(self._stl_list[resol])
tmp_l2_filename_list.append(tmp_stl_filename)
# START WRITING ATB Image file DATA
# Initialize the Scalar filter
# FA1424: Temporary Fix to address cosmetic aspects of FA1424
# VAPThreshold.SetInput(self.GetVAPImageList()[resol))
# VAPThreshold.SetOutsideValue(255. / p_VAPQuantificationValue)
# VAPThreshold.ThresholdAbove(255. / p_VAPQuantificationValue)
# VAPScalar.SetInput(VAPThreshold.GetOutput())
# VAPScalar.SetCoef(p_VAPQuantificationValue)
atb_pipeline = OtbPipelineManager()
tmp_vap = os.path.join(
working_dir, "tmp_vap_scaled_" + l_StrResolution + ".tif")
param_bandmath_vap = {
"il":
[self._l2vapimagelist[resol], self._l2edgimagelist[resol]],
"exp":
"(im2b1 == 1)?" + str(p_VAPNodataValue) + ":" + "im1b1*" +
str(p_VAPQuantificationValue),
"out":
tmp_vap
}
vap_scal_app = OtbAppHandler("BandMathDouble",
param_bandmath_vap,
write_output=False)
atb_pipeline.add_otb_app(vap_scal_app)
tmp_round_vap = os.path.join(
working_dir, "tmp_vap_round_" + l_StrResolution + ".tif")
param_round_vap = {
"im": vap_scal_app.getoutput().get("out"),
"out": tmp_round_vap
}
vap_round_app = OtbAppHandler("RoundImage",
param_round_vap,
write_output=False)
atb_pipeline.add_otb_app(vap_round_app)
tmp_aot = os.path.join(
working_dir, "tmp_aot_scaled_" + l_StrResolution + ".tif")
param_bandmath_aot = {
"il":
[self._l2aotlist[resol], self._l2edgimagelist[resol]],
"exp":
"(im2b1 == 1)?" + str(p_AOTNodataValue) + ":" + "im1b1*" +
str(p_AOTQuantificationValue),
"out":
tmp_aot
}
aot_scal_app = OtbAppHandler("BandMathDouble",
param_bandmath_aot,
write_output=False)
atb_pipeline.add_otb_app(aot_scal_app)
tmp_round_aot = os.path.join(
working_dir, "tmp_aot_round_" + l_StrResolution + ".tif")
param_round_aot = {
"im": aot_scal_app.getoutput().get("out"),
"out": tmp_round_aot
}
aot_round_app = OtbAppHandler("RoundImage",
param_round_aot,
write_output=False)
atb_pipeline.add_otb_app(aot_round_app)
atb_filename = l_BaseL2FullFilename + "_ATB_" + l_grpSuffix + ".tif"
param_atb_concat = {
"il": [
vap_round_app.getoutput().get("out"),
aot_round_app.getoutput().get("out")
],
"out":
atb_filename + ":uint8" + file_utils.
get_extended_filename_write_image_file_standard()
}
atb_binconcat_app = OtbAppHandler("ConcatenateImages",
param_atb_concat,
write_output=False)
#tmp_l2_image_list.append(atb_binconcat_app.getoutput().get("out"))
#tmp_l2_filename_list.append(atb_filename)
atb_pipeline.add_otb_app(atb_binconcat_app)
# START WRITING IAB MASK
iab_pipeline = OtbPipelineManager()
# Create the image list
tmp_iab = os.path.join(
working_dir, "tmp_iab_concat_" + l_StrResolution + ".tif")
param_iab_concat = {
"il":
[self._l2iwcmasklist[resol], self._l2taomasklist[resol]],
"out": tmp_iab + ":uint8"
}
tmp_iab_concat_app = OtbAppHandler("ConcatenateImages",
param_iab_concat,
write_output=False)
iab_pipeline.add_otb_app(tmp_iab_concat_app)
iab_filename = l_BaseL2FullMASKSFilename + "_IAB_" + l_grpSuffix + ".tif"
param_iab_binconcat = {
"im":
tmp_iab_concat_app.getoutput().get("out"),
"out":
iab_filename + ":uint8" + file_utils.
get_extended_filename_write_image_file_standard()
}
iab_binconcat_app = OtbAppHandler("BinaryConcatenate",
param_iab_binconcat,
write_output=False)
iab_pipeline.add_otb_app(iab_binconcat_app)
write_images([
atb_binconcat_app.getoutput().get("out"),
iab_binconcat_app.getoutput().get("out")
], [atb_filename, iab_filename])
#tmp_l2_image_list.append(iab_binconcat_app.getoutput().get("out"))
#tmp_l2_filename_list.append(iab_filename)
# START WRITING EDG Image file DATA
tmp_l2_image_list.append(self._l2edgimagelist[resol])
tmp_l2_filename_list.append(l_BaseL2FullMASKSFilename +
"_EDG_" + l_grpSuffix + ".tif")
#--------------------------
# Write all the images at L2 Reso
write_images(tmp_l2_image_list, tmp_l2_filename_list)
atb_pipeline.free_otb_app()
iab_pipeline.free_otb_app()
fre_pipeline.free_otb_app()
sre_pipeline.free_otb_app()
# --------------------------
#Caching of cloud images needed for MG2
l_cm2_index = p_CLDCoreAlgorithmsMapBand[CLOUD_MASK_ALL_CLOUDS]
l_shadows_index = p_CLDCoreAlgorithmsMapBand[
CLOUD_MASK_SHADOWS]
l_shadvar_index = p_CLDCoreAlgorithmsMapBand[
CLOUD_MASK_SHADVAR]
# START WRITING MG2 Image file DATA
l_mg2_image_list = []
mg2_pipeline = OtbPipelineManager()
# Connect the WAM image
wat_resampled = os.path.join(
working_dir, "wat_resampled_" + l_StrResolution + ".tif")
app_resample_wat = resample(self._wasimage,
self._dtm.ALTList[resol],
wat_resampled,
method=OtbResampleType.LINEAR,
threshold=0.25,
write_output=False)
l_mg2_image_list.append(
app_resample_wat.getoutput().get("out"))
mg2_pipeline.add_otb_app(app_resample_wat)
# Extract the CM2 cloud mask
l_mg2_image_list.append(self._l2cldlist[resol][l_cm2_index])
#Connect the SNW image if any
if self._cld_snow is not None:
LOGGER.debug(
"Snow mask has been successfully computed, adding it to the MG2"
)
snw_resampled = os.path.join(
working_dir,
"snw_resampled_" + l_StrResolution + ".tif")
app_resample_snw = resample(self._cld_snow,
self._dtm.ALTList[resol],
snw_resampled,
method=OtbResampleType.LINEAR,
threshold=0.25,
write_output=False)
l_mg2_image_list.append(
app_resample_snw.getoutput().get("out"))
mg2_pipeline.add_otb_app(app_resample_snw)
else:
# Add a constant mask
tmp_constant_filename = os.path.join(
working_dir, "Const_shd_masks.tif")
cst_snw_app = constant_image(self._dtm.ALTList[resol],
0,
tmp_constant_filename +
":uint8",
write_output=False)
l_mg2_image_list.append(cst_snw_app.getoutput().get("out"))
mg2_pipeline.add_otb_app(cst_snw_app)
# Connect the shadow or mask
tmp_shador_bandmath = os.path.join(
working_dir,
"tmp_shador_bandmath_" + l_StrResolution + ".tif")
tmp_band_math_app = band_math([
self._l2cldlist[resol][l_shadows_index],
self._l2cldlist[resol][l_shadvar_index]
],
"im1b1 || im2b1",
tmp_shador_bandmath + ":uint8",
write_output=False)
l_mg2_image_list.append(
tmp_band_math_app.getoutput().get("out"))
mg2_pipeline.add_otb_app(tmp_band_math_app)
# Connect the HID image
hid_resampled = os.path.join(
working_dir, "hid_resampled_" + l_StrResolution + ".tif")
app_resample_hid = resample(self._dtm_hid,
self._dtm.ALTList[resol],
hid_resampled,
method=OtbResampleType.LINEAR,
threshold=0.25,
write_output=False)
l_mg2_image_list.append(
app_resample_hid.getoutput().get("out"))
mg2_pipeline.add_otb_app(app_resample_hid)
# Connect the SHDimage
shd_resampled = os.path.join(
working_dir, "shd_resampled_" + l_StrResolution + ".tif")
app_resample_shd = resample(self._dtm_shd,
self._dtm.ALTList[resol],
shd_resampled,
method=OtbResampleType.LINEAR,
threshold=0.25,
write_output=False)
mg2_pipeline.add_otb_app(app_resample_shd)
l_mg2_image_list.append(
app_resample_shd.getoutput().get("out"))
if p_EnvCorOption:
# Append STL
l_mg2_image_list.append(tmp_stl_filename)
# Append TGS
l_mg2_image_list.append(tmp_tgs_filename)
else:
# Append STL
l_mg2_image_list.append(self._stl_list[resol])
# Append TGS
l_mg2_image_list.append(self._tgs_list[resol])
# Concatenate all
tmp_mg2 = os.path.join(
working_dir, "tmp_mg2_concat_" + l_StrResolution + ".tif")
param_mg2_concat = {"il": l_mg2_image_list, "out": tmp_mg2}
tmp_mg2_concat_app = OtbAppHandler("ConcatenateImages",
param_mg2_concat,
write_output=False)
param_mg2_binconcat = {
"im":
tmp_mg2_concat_app.getoutput().get("out"),
"out":
l_BaseL2FullMASKSFilename + "_MG2_" + l_grpSuffix +
".tif" + ":uint8" + file_utils.
get_extended_filename_write_image_file_standard()
}
mg2_binconcat_app = OtbAppHandler("BinaryConcatenate",
param_mg2_binconcat,
write_output=True)
mg2_pipeline.add_otb_app(mg2_binconcat_app)
mg2_pipeline.free_otb_app()
# START WRITING SAT Image file DATA
# TODO Create the writer with test on number of bands
param_sat_binconcat = {
"im":
self._l2satimagelist[resol],
"out":
l_BaseL2FullMASKSFilename + "_SAT_" + l_grpSuffix +
".tif" + ":uint8" + file_utils.
get_extended_filename_write_image_file_standard()
}
sat_binconcat_app = OtbAppHandler("BinaryConcatenate",
param_sat_binconcat,
write_output=True)
# START WRITING PIX Image file DATA
if "PIXImages" in self._l1_image_info.MuscateData:
LOGGER.debug(
"The L1 product have 'Aberrant_Pixels' masks. There are writed in the L2 out product..."
)
otb_file_utils.otb_copy_image_to_file(
self._l2piximagelist[resol],
l_BaseL2FullMASKSFilename + "_PIX_" + l_grpSuffix +
".tif")
else:
LOGGER.debug("No PIX node detected to write")
# START WRITING USI Image file DATA
if "Node_Useful_Image" in self._l1_image_info.MuscateData:
LOGGER.debug(
"The L1 product have 'Useful_Image' files. There are copied in the L2 out product..."
)
# Write the USI in the Xml file, in the Useful_Imagenode !
l_XPathRootUSI_In = "//Mask[Mask_Properties/NATURE='Useful_Image']/Mask_File_List/MASK_FILE[@group_id='{}']"
xnodes_in = xml_tools.get_all_values(
self._l1_image_info.MuscateData["Node_Useful_Image"],
l_XPathRootUSI_In.format(l_grpSuffix))
# Get the path in the xml product filename
lPath = os.path.dirname(self._l1_image_info.HeaderFilename)
for node_in in xnodes_in:
l_FullPathFilename = os.path.join(lPath, node_in.text)
# Expand threshold the file
usi_resampled = l_BaseL2FullMASKSFilename + "_USI_" + l_grpSuffix + ".tif"\
+ file_utils.get_extended_filename_write_mask_file_muscate()
resample(l_FullPathFilename,
self._dtm.ALTList[resol],
usi_resampled,
threshold=0.25,
method=OtbResampleType.LINEAR,
write_output=True)
else:
LOGGER.debug(
"No 'Useful_Image' mask detected in the L1 product."
)
# Fin si manage USI
# START WRITING DFP Image file DATA (=DFP in MUSCATE) #TODO
if self._l2dfpimagelist is not None:
param_dfp_binconcat = {
"im":
self._l2dfpimagelist[resol],
"out":
l_BaseL2FullMASKSFilename + "_DFP_" + l_grpSuffix +
".tif"
}
dfp_binconcat_app = OtbAppHandler("BinaryConcatenate",
param_dfp_binconcat,
write_output=True)
else:
LOGGER.debug("DFP Masks not available.")
# START WRITING CLM (CLD) Image file DATA
# Connect the CLD image
# Connect the CLD image
# -------------------------------------
l_cld_uses_filenames = False
for f in self._l2cldlist[resol]:
if not otb_is_swig_pointer(f) and os.path.exists(f):
l_cld_uses_filenames = True
self.write_cld_image(self._l2cldlist[resol],
p_CLDDataBandsSelected,
l_BaseL2FullMASKSFilename + "_CLM_" +
l_grpSuffix + ".tif",
use_filenames=l_cld_uses_filenames)
LOGGER.debug("Writing L2 resolution image done !")
