def otb_copy_file_to_directory(sourceFilename, destinationDir):
destinationFilename = os.path.join(destinationDir, os.path.basename(sourceFilename))
if not get_test_mode():
if type(sourceFilename).__name__ == "SwigPyObject":
write_images([sourceFilename], [destinationFilename])
else:
shutil.copyfile(sourceFilename, destinationFilename)
else:
with open(destinationFilename, 'a'):
os.utime(destinationFilename, None)
return destinationFilename
def otb_copy_image_to_file(source, dest, raise_exceptions=True):
if not get_test_mode():
if type(source).__name__ == "SwigPyObject":
write_images([source], [dest])
else:
LOGGER.debug("source : " + source + " , dest : " + dest)
try:
if not os.path.exists(dest) or not os.path.samefile(source, dest):
shutil.copyfile(source, dest)
except IOError as err:
if raise_exceptions:
raise MajaIOError(err)
else:
LOGGER.warn("Copy failed !!!")
else:
with open(dest, 'a'):
os.utime(dest, None)
def run(self, dict_of_input, dict_of_output):
LOGGER.info("Water vapor post processing Correction start")
caching = dict_of_input.get("Params").get("Caching")
wvpp_working = dict_of_input.get(
"AppHandler").get_directory_manager().get_temporary_directory(
"WaterVaporPPProc_", do_always_remove=True)
vap_default = float(
dict_of_input.get("L2COMM").get_value("WaterAmountDefaultValue"))
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
l_nbRes = len(bands_definition.ListOfL2Resolution)
# Does the user choose to compute the VAP image ? (GIP_L2COMM_UseDefaultConstantWaterAmount)
l_UseDefaultConstantWaterAmount = False
if not dict_of_input.get("Plugin").WaterVapourDetermination or as_bool(
dict_of_input.get("L2COMM").get_value(
"GIP_L2COMM_UseDefaultConstantWaterAmount")):
l_UseDefaultConstantWaterAmount = True
vap_list = []
vapmask_list = []
if l_UseDefaultConstantWaterAmount:
for r in range(0, l_nbRes):
l_res = bands_definition.ListOfL2Resolution[r]
vap_image_filename = os.path.join(wvpp_working,
"vap_" + l_res + ".tif")
vap_mask_filename = os.path.join(
wvpp_working, "vapmask_" + l_res + ".tif:uint8")
vap_image = constant_image(dict_of_input.get("DEM").ALTList[r],
vap_default,
vap_image_filename,
write_output=False)
self._l2_pipeline.add_otb_app(vap_image)
dict_of_output["VAP_" + l_res] = vap_image.getoutput()["out"]
vap_mask = constant_image(dict_of_input.get("DEM").ALTList[r],
0,
vap_mask_filename,
write_output=False)
self._l2_pipeline.add_otb_app(vap_mask)
dict_of_output["VAPMASK_" +
l_res] = vap_mask.getoutput()["out"]
vap_list.append(dict_of_output["VAP_" + l_res])
vapmask_list.append(dict_of_output["VAPMASK_" + l_res])
else:
l_refbandcode = dict_of_input.get("L2COMM").get_value(
"WaterVaporReferenceBandCode")
l_bandcode = dict_of_input.get("L2COMM").get_value(
"WaterVaporBandCode")
vap_subimage_filename = os.path.join(wvpp_working, "vap_sub.tif")
vap_submask_filename = os.path.join(wvpp_working,
"vapmask_sub.tif")
param_watervpp = {
"tocr":
dict_of_output["RayleighIPTOCR"],
"vapin":
dict_of_output["VAP_Sub"],
"cldsum":
dict_of_output[constants.CLOUD_MASK_ALL],
"defaultwatervapor":
vap_default,
"threshold":
dict_of_input.get("L2COMM").get_value_f(
"WaterVaporReflectanceThreshold"),
"thresholdref":
dict_of_input.get("L2COMM").get_value_f(
"WaterVaporReflectanceThresholdRef"),
"referencebandcode":
bands_definition.get_band_id_in_l2_coarse(l_refbandcode),
"bandcode":
bands_definition.get_band_id_in_l2_coarse(l_bandcode),
"nodata":
dict_of_input.get("L2COMM").get_value_f("VAPNodataValue"),
"sevalidradius":
dict_of_input.get("L2COMM").get_value_i(
"WaterVaporSEValidRadius"),
"initwindowradius":
dict_of_input.get("L2COMM").get_value_i(
"WaterVaporInitWindowRadius"),
"maxwindowradius":
dict_of_input.get("L2COMM").get_value_i(
"WaterVaporMaxWindowRadius"),
"mask":
vap_submask_filename + ":uint8",
"vap":
vap_subimage_filename
}
watervpp_app = OtbAppHandler("WaterVaporPostPro",
param_watervpp,
write_output=False)
self._l2_pipeline.add_otb_app(watervpp_app)
for r in range(0, l_nbRes):
l_res = bands_definition.ListOfL2Resolution[r]
vap_image_filename = os.path.join(wvpp_working,
"vap_" + l_res + ".tif")
vap_mask_filename = os.path.join(wvpp_working,
"vapmask_" + l_res + ".tif")
param_subresampling = {
"dtm": dict_of_input.get("DEM").ALTList[r],
"im": watervpp_app.getoutput()["vap"],
"interp": "linear",
"out": vap_image_filename
}
subresampling_app = OtbAppHandler("Resampling",
param_subresampling,
write_output=False)
self._l2_pipeline.add_otb_app(subresampling_app)
param_maskresampling = {
"dtm": dict_of_input.get("DEM").ALTList[r],
"im": watervpp_app.getoutput()["mask"],
"interp": "linear",
"out": vap_mask_filename + ":uint8",
"threshold": 0.25
}
maskresampling_app = OtbAppHandler("Resampling",
param_maskresampling,
write_output=False)
self._l2_pipeline.add_otb_app(maskresampling_app)
if is_croco_on("watervaporpostprocessing"):
write_images([
subresampling_app.getoutput()["out"],
maskresampling_app.getoutput()["out"]
], [vap_image_filename, vap_mask_filename])
dict_of_output["VAP_" + l_res] = vap_image_filename
dict_of_output["VAPMASK_" + l_res] = vap_mask_filename
else:
dict_of_output[
"VAP_" + l_res] = subresampling_app.getoutput()["out"]
dict_of_output[
"VAPMASK_" +
l_res] = maskresampling_app.getoutput()["out"]
vap_list.append(dict_of_output["VAP_" + l_res])
vapmask_list.append(dict_of_output["VAPMASK_" + l_res])
dict_of_output["L2VAPList"] = vap_list
dict_of_output["L2VAPMaskList"] = vapmask_list
def _gamma_compute_at_res(self, dict_of_input, dict_of_output, p_res,
p_working):
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
l_res = bands_definition.ListOfL2Resolution[p_res]
LOGGER.info("Cirrus gamma compute at res " + l_res + " start")
# ---------- Resample L1 Cirrus to resolution ---------------
l1cirrus_resampled = os.path.join(p_working,
"toacirrus_" + l_res + ".tif")
param_l1cirrus_resample = {
"dtm": dict_of_input.get("DEM").ALTList[p_res],
"im": dict_of_input.get("L1Reader").get_value("L1TOACirrusImage"),
"interp": "bco",
"out": l1cirrus_resampled
}
app_l1cirrus_resamp = OtbAppHandler("Resampling",
param_l1cirrus_resample,
write_output=True)
# ---------- Resample Cirrus cloud to resolution ---------------
cld_cirrus_resampled = dict_of_output[CLOUD_MASK_CIRRUS + "_" + l_res]
cirrusmask_resampled = os.path.join(p_working,
"cirrusmask_" + l_res + ".tif")
# ---------- Resample All cloud to resolution ---------------
cld_all_resampled = dict_of_output[CLOUD_MASK_ALL + "_" + l_res]
allmask_resampled = os.path.join(p_working,
"allmask_" + l_res + ".tif")
# ---------- Resample Refl cloud to resolution ---------------
cld_refl_resampled = dict_of_output[CLOUD_MASK_REFL + "_" + l_res]
allreflresampled = os.path.join(p_working,
"reflmask_" + l_res + ".tif")
# ----- Caching of L2TOA
l2toa_cach = os.path.join(p_working, "l2toa_" + l_res + ".tif")
#Write to caching
write_images([
cld_cirrus_resampled, cld_all_resampled, cld_refl_resampled,
dict_of_output["L2TOA_" + l_res]
], [
cirrusmask_resampled, allmask_resampled, allreflresampled,
l2toa_cach
])
# Update dict
clean_pipe(dict_of_output[CLOUD_MASK_CIRRUS + "_" + l_res])
clean_pipe(dict_of_output[CLOUD_MASK_ALL + "_" + l_res])
clean_pipe(dict_of_output[CLOUD_MASK_REFL + "_" + l_res])
clean_pipe(dict_of_output["L2TOA_" + l_res])
dict_of_output[CLOUD_MASK_CIRRUS + "_" + l_res] = cirrusmask_resampled
dict_of_output[CLOUD_MASK_ALL + "_" + l_res] = allmask_resampled
dict_of_output[CLOUD_MASK_REFL + "_" + l_res] = allreflresampled
dict_of_output["L2TOA_" + l_res] = l2toa_cach
# --------------------- Gamma compute for the resolution
# construct band list
gamm_band_list = xml_tools.as_string_list(
dict_of_input.get("L2COMM").get_value(
"CirrusCorrectionGammaBandCodes"))
l_l2bandcodes = bands_definition.get_list_of_l2_band_code(l_res)
l_resbandlist = []
for i in range(0, len(l_l2bandcodes)):
if l_l2bandcodes[i] in gamm_band_list:
l_resbandlist.append(str(i))
cirrus_mask = os.path.join(p_working,
"cirrus_corr_mask_" + l_res + ".tif")
param_gamma_compute = {
"l2toa":
l2toa_cach,
"l2edg":
dict_of_input.get("L1Reader").get_value("L2EDGOutputList")[p_res],
"l2dtm":
dict_of_input.get("DEM").ALTList[p_res],
"l2cirrus":
app_l1cirrus_resamp.getoutput().get("out"),
"bandlist":
l_resbandlist,
"cloudcirrus":
cirrusmask_resampled,
"cloudall":
allmask_resampled,
"cloudrefl":
allreflresampled,
"cirrusminpixinlist":
int(
dict_of_input.get("L2COMM").get_value(
"CirrusCorrectionMinPixInList")),
"mask":
cirrus_mask + ":uint8"
}
gamma_compute_app = OtbAppHandler("GammaCompute",
param_gamma_compute,
write_output=True)
cirr_flag = bool(gamma_compute_app.getoutput()["cirrusflag"])
gamma = float(gamma_compute_app.getoutput()["gamma"])
del gamma_compute_app
del app_l1cirrus_resamp
return [
l1cirrus_resampled, cirrus_mask, cirr_flag,
len(l_resbandlist), gamma
]
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 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 run(self, dict_of_input, dict_of_output):
LOGGER.info("Environment Correction start")
env_working = dict_of_input.get("AppHandler").get_directory_manager().get_temporary_directory("EnvoCorrProc_",
do_always_remove=True)
l_envcorradius = dict_of_input.get("L2COMM").get_value_f("EnvCorrRadius")
l_envcorsize = (2 * l_envcorradius + 1) * (2 * l_envcorradius + 1)
caching = dict_of_input.get("Params").get("Caching")
# Compute rho env sub
rhoenv_sub_image = os.path.join(env_working, "rhoenv_sub.tif")
param_computerho = {"toc": dict_of_output["TOC_sub"],
"edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"),
"radius": l_envcorradius,
"filtercoeff": 1.0 / l_envcorsize,
"rhoenv": rhoenv_sub_image}
computerho_app = OtbAppHandler("ComputeRhoEnv", param_computerho, write_output=True)
# Interpolate for env
tdif_filename = os.path.join(env_working, "tdif_sub.tif")
tdir_filename = os.path.join(env_working, "tdir_sub.tif")
albd_filename = os.path.join(env_working, "albd_sub.tif")
param_interpolate = {"luttdir": dict_of_input.get("L2DIRT"),
"luttdif": dict_of_input.get("L2DIFT"),
"lutalbd": dict_of_input.get("L2ALBD"),
"aot": dict_of_output["AOT_Sub"],
"dtm": dict_of_input.get("DEM").ALC,
"edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"),
"thetav": dict_of_input.get(
"L1Info").ListOfViewingZenithAnglesPerBandAtL2CoarseResolution,
"tdir": tdir_filename,
"tdif": tdif_filename,
"albd": albd_filename
}
interpolate_app = OtbAppHandler("InterpolateForEnvCorr", param_interpolate, write_output=True)
tdif_image = interpolate_app.getoutput()["tdif"]
tdir_image = interpolate_app.getoutput()["tdir"]
albd_image = interpolate_app.getoutput()["albd"]
# Compute env corr for each l2 resolution
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
l_nbRes = len(bands_definition.ListOfL2Resolution)
sre_list = []
for r in range(0, l_nbRes):
l_res = bands_definition.ListOfL2Resolution[r]
l_l2bandcodes = bands_definition.get_list_of_l2_band_code(l_res)
l_l2bandidx = [bands_definition.get_band_id_in_l2_coarse(b) for b in l_l2bandcodes]
tdifl2_filename = os.path.join(env_working, "tdif_" + l_res + ".tif")
tdirl2_filename = os.path.join(env_working, "tdir_" + l_res + ".tif")
albdl2_filename = os.path.join(env_working, "albd_" + l_res + ".tif")
rhoenvl2_filename= os.path.join(env_working, "rhoenv_extract_" + l_res + ".tif")
# Extract tdif
tdifl2_image_app = extract_roi(tdif_image, l_l2bandidx, tdifl2_filename, write_output=False)
self._l2_pipeline.add_otb_app(tdifl2_image_app)
# Extract tdir
tdirl2_image_app = extract_roi(tdir_image, l_l2bandidx, tdirl2_filename, write_output=False)
self._l2_pipeline.add_otb_app(tdirl2_image_app)
# Extract albd
albdl2_image_app = extract_roi(albd_image, l_l2bandidx, albdl2_filename, write_output=False)
self._l2_pipeline.add_otb_app(albdl2_image_app)
# Extract rhoenv_sub
rhoenvl2_image_app = extract_roi(computerho_app.getoutput().get("rhoenv"), l_l2bandidx, rhoenvl2_filename, write_output=False)
self._l2_pipeline.add_otb_app(rhoenvl2_image_app)
rhoenv_image = os.path.join(env_working, "rhoenv_" + l_res + ".tif")
sre_image = os.path.join(env_working, "sre_" + l_res + ".tif")
# Compute env correction
param_envcorr = {"tdir": tdirl2_image_app.getoutput()["out"],
"tdif": tdifl2_image_app.getoutput()["out"],
"albd": albdl2_image_app.getoutput()["out"],
"rhoenvsub": rhoenvl2_image_app.getoutput()["out"],
"nodata": dict_of_input.get("Params").get("RealL2NoData"),
"toc": dict_of_output["TOC_" + l_res],
"edg": dict_of_input.get("L1Reader").get_value("L2EDGOutputList")[r],
"sre": sre_image,
"rhoenv": rhoenv_image
}
envcorr_app = OtbAppHandler("EnvCorrection", param_envcorr,write_output=False)
self._l2_pipeline.add_otb_app(envcorr_app)
if is_croco_on("envcorrection"):
write_images([envcorr_app.getoutput().get("sre"), envcorr_app.getoutput().get("rhoenv")],
[sre_image, rhoenv_image])
dict_of_output["SRE_" + l_res] = sre_image
dict_of_output["RhoEnv_" + l_res] = rhoenv_image
sre_list.append(sre_image)
else:
dict_of_output["SRE_" + l_res] = envcorr_app.getoutput().get("sre")
dict_of_output["RhoEnv_" + l_res] = envcorr_app.getoutput().get("rhoenv")
sre_list.append(envcorr_app.getoutput().get("sre"))
dict_of_output["SRE_List"] = sre_list
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 !")
def run(self, dict_of_input, dict_of_output):
LOGGER.info("Slope Correction start")
slope_working = dict_of_input.get(
"AppHandler").get_directory_manager().get_temporary_directory(
"SlopeCorrProc_", do_always_remove=True)
caching = dict_of_input.get("Params").get("Caching")
# Compute transmission
tdif_image = os.path.join(slope_working, "tdif_sub.tif")
tdir_image = os.path.join(slope_working, "tdir_sub.tif")
param_interpolate = {
"luttdir":
dict_of_input.get("L2DIRT"),
"luttdif":
dict_of_input.get("L2DIFT"),
"aot":
dict_of_output["AOT_Sub"],
"dtm":
dict_of_input.get("DEM").ALC,
"edg":
dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"),
"thetas":
float(dict_of_input.get("L1Info").SolarAngle["sun_zenith_angle"]),
"tdir":
tdir_image,
"tdif":
tdif_image
}
interpolate_app = OtbAppHandler("ComputeTransmission",
param_interpolate,
write_output=True)
# Compute env corr for each l2 resolution
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
l_nbRes = len(bands_definition.ListOfL2Resolution)
fre_list = []
stl_list = []
tgs_list = []
for r in range(0, l_nbRes):
l_res = bands_definition.ListOfL2Resolution[r]
l_l2bandcodes = bands_definition.get_list_of_l2_band_code(l_res)
l_l2bandidx = [
bands_definition.get_band_id_in_l2_coarse(b)
for b in l_l2bandcodes
]
l_l2bandchannels = ["Channel" + str(b + 1) for b in l_l2bandidx]
tdifl2_filename = os.path.join(slope_working,
"tdif_" + l_res + ".tif")
tdirl2_filename = os.path.join(slope_working,
"tdir_" + l_res + ".tif")
fre_image = os.path.join(slope_working, "fre_" + l_res + ".tif")
tgs_image = os.path.join(slope_working, "tgs_" + l_res + ".tif")
stl_image = os.path.join(slope_working, "stl_" + l_res + ".tif")
incangle_image = os.path.join(slope_working,
"incangle_" + l_res + ".tif")
# Extract tdif
tdifl2_app = extract_roi(interpolate_app.getoutput()["tdif"],
l_l2bandidx,
tdifl2_filename,
write_output=False)
self._l2_app_pipeline.add_otb_app(tdifl2_app)
tdifl2_image = tdifl2_app.getoutput()["out"]
# Extract tdir
tdirl2_app = extract_roi(interpolate_app.getoutput()["tdir"],
l_l2bandidx,
tdirl2_filename,
write_output=False)
self._l2_app_pipeline.add_otb_app(tdirl2_app)
tdirl2_image = tdirl2_app.getoutput()["out"]
# Compute incidence angles
param_incangle = {
"demasc":
dict_of_input.get("DEM").ASPList[r],
"demslc":
dict_of_input.get("DEM").SLPList[r],
"thetas":
float(
dict_of_input.get(
"L1Info").SolarAngle["sun_zenith_angle"]),
"phis":
float(
dict_of_input.get(
"L1Info").SolarAngle["sun_azimuth_angle"]),
"angles":
incangle_image
}
incangle_app = OtbAppHandler("IncidenceAngle",
param_incangle,
write_output=False)
self._l2_app_pipeline.add_otb_app(incangle_app)
# Compute slope correction
l_thetav = []
l_phiv = []
for ang in [
dict_of_input.get("L1Info").
ListOfViewingAnglesPerBandAtL2CoarseResolution[b]
for b in l_l2bandidx
]:
l_thetav.append(ang.get("incidence_zenith_angle"))
l_phiv.append(ang.get("incidence_azimuth_angle"))
param_slopecorr = {
"tdirsub":
tdirl2_image,
"tdifsub":
tdifl2_image,
"dtmasc":
dict_of_input.get("DEM").ASPList[r],
"dtmslc":
dict_of_input.get("DEM").SLPList[r],
"rhoenv":
dict_of_output["RhoEnv_" + l_res],
"incangle":
incangle_app.getoutput().get("angles"),
"sre":
dict_of_output["SRE_" + l_res],
"thetas":
float(
dict_of_input.get(
"L1Info").SolarAngle["sun_zenith_angle"]),
"phis":
float(
dict_of_input.get(
"L1Info").SolarAngle["sun_azimuth_angle"]),
"thetav":
l_thetav,
"phiv":
l_phiv,
"mincosi":
dict_of_input.get("L2COMM").get_value_f("SlopeMinCosI"),
"mincose":
dict_of_input.get("L2COMM").get_value_f("MinCosE"),
"mincosratio":
dict_of_input.get("L2COMM").get_value_f("MinCosRatio"),
"nodata":
dict_of_input.get("Params").get("RealL2NoData"),
"fre":
fre_image,
"tgs":
tgs_image,
"stl":
stl_image
}
slope_app = OtbAppHandler("SlopeCorrection",
param_slopecorr,
write_output=False)
self._l2_app_pipeline.add_otb_app(slope_app)
if is_croco_on("slopecorrection"):
dict_of_output["FRE_" + l_res] = fre_image
dict_of_output["TGS_" + l_res] = tgs_image
dict_of_output["STL_" + l_res] = stl_image
write_images([
slope_app.getoutput().get("fre"),
slope_app.getoutput().get("tgs"),
slope_app.getoutput().get("stl")
], [fre_image, tgs_image, stl_image])
else:
dict_of_output["FRE_" +
l_res] = slope_app.getoutput().get("fre")
dict_of_output["TGS_" +
l_res] = slope_app.getoutput().get("tgs")
dict_of_output["STL_" +
l_res] = slope_app.getoutput().get("stl")
fre_list.append(dict_of_output["FRE_" + l_res])
tgs_list.append(dict_of_output["TGS_" + l_res])
stl_list.append(dict_of_output["STL_" + l_res])
dict_of_output["FRE_List"] = fre_list
dict_of_output["TGS_List"] = tgs_list
dict_of_output["STL_List"] = stl_list