def generate_l2_toa_images(self, working_dir): """ :param 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] # 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 list_of_image.append(self._toa_scalar_list[l1BandIdx]) out_concatenate = os.path.join( working_dir, "L2TOAImageListVector_" + curRes + ".tif") param_concatenate = {"il": list_of_image, "out": out_concatenate} l2toa_concat_app = OtbAppHandler( "ConcatenateDoubleImages", param_concatenate, write_output=(False or is_croco_on("sentinel2.l1reader.l2toa"))) self._pipeline.add_otb_app(l2toa_concat_app) self._l2toaimagelist.append( l2toa_concat_app.getoutput().get("out"))
def run(self, dict_of_input, dict_of_output): LOGGER.info("Scattering Correction start") scat_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "ScatteringProc_", do_always_remove=True) l_caching = dict_of_input.get("Params").get("Caching") l_writeL2 = dict_of_input.get("Params").get( "WriteL2ProductToL2Resolution") tocr_sub_image = os.path.join(scat_working, "tocr_sub.tif") bands_definition = dict_of_input.get("Plugin").BandsDefinitions # Coarse scattering correction param_scattering = { "lutmap": dict_of_output["hr_lutmap"], "toac": dict_of_output["AtmoAbsIPTOAC"], "aot": dict_of_output["AOT_Sub"], "edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"), "dtm": dict_of_input.get("DEM").ALC, "l2nodata": dict_of_input.get("Params").get("RealL2NoData"), "l2bandincoarse": bands_definition.get_list_of_band_id_in_l2_coarse(), "tocr": tocr_sub_image } self._scattering_sub_app = OtbAppHandler("ScatteringCorrection", param_scattering, write_output=False) dict_of_output["TOC_sub"] = self._scattering_sub_app.getoutput( )["tocr"] # l2 scattering correction tocr_list = [] if l_writeL2: l_nbRes = len(bands_definition.ListOfL2Resolution) for r in range(0, l_nbRes): l_res = bands_definition.ListOfL2Resolution[r] tocr_image = os.path.join(scat_working, "tocr_" + l_res + ".tif") if dict_of_input.get("Plugin").WideFieldSensor: param_scattering["anglezone"] = dict_of_input.get( "L1Reader").get_value("AngleZoneMaskList")[r] param_scattering["dtm"] = dict_of_input.get("DEM").ALTList[r] param_scattering["edg"] = dict_of_input.get( "L1Reader").get_value("L2EDGOutputList")[r] param_scattering["aot"] = dict_of_output["AOT_" + l_res] param_scattering["toac"] = dict_of_output["L2TOA_" + l_res] param_scattering["tocr"] = tocr_image l_l2bandids = bands_definition.get_list_of_l2_coarse_band_id_associated_to_l2_band_code( bands_definition.get_list_of_l2_band_code(l_res)) param_scattering["l2bandincoarse"] = [ str(b) for b in l_l2bandids ] scat_app = OtbAppHandler( "ScatteringCorrection", param_scattering, write_output=is_croco_on("scatteringcorrection")) self._l2_pipeline.add_otb_app(scat_app) dict_of_output["TOC_" + l_res] = scat_app.getoutput().get("tocr") tocr_list.append(dict_of_output["TOC_" + l_res]) dict_of_output["L2TOCList"] = tocr_list
def __init__(self, otb_app, parameters, write_output=True): self._c1 = MajaOtbCots() self._app_name = otb_app LOGGER.debug("Initializing : " + self._app_name) if "ram" not in list(parameters.keys()): curr_ram = int(memory_used_by_process_current(os.getpid())) avail_ram = OtbAppHandler.ram_to_use - curr_ram if avail_ram < OtbAppHandler.ram_to_use/OtbAppHandler.ram_limit_factor: parameters["ram"] = str(OtbAppHandler.ram_to_use / OtbAppHandler.ram_limit_factor) else: parameters["ram"] = str(avail_ram) LOGGER.debug(parameters) self._write_output = not is_croco_off() and (write_output or is_croco_on()) self._c1.pre(otb_app, parameters) if not get_test_mode(): self._run() self._post()
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 run(self, dict_of_input, dict_of_output): LOGGER.info("Cirrus Correction start") cirrus_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "CirrusCorrProc_", do_always_remove=True) refres_name = dict_of_input.get( "Plugin").CirrusCorrectionReferenceResolution refres_idx = 9999 bands_definition = dict_of_input.get("Plugin").BandsDefinitions for i in range(0, len(bands_definition.ListOfL2Resolution)): if bands_definition.ListOfL2Resolution[i] == refres_name: refres_idx = i # TODO test refres_idx result = {} ref_result = self._gamma_compute_at_res(dict_of_input, dict_of_output, refres_idx, cirrus_working) result[bands_definition.ListOfL2Resolution[refres_idx]] = ref_result if ref_result[2]: LOGGER.info("Cirrus flag enabled on reference resolution") l_gammamean = ref_result[3] * ref_result[4] l_nbgamma = ref_result[3] for i in range(0, len(bands_definition.ListOfL2Resolution)): if bands_definition.ListOfL2Resolution[i] != refres_name: res_result = self._gamma_compute_at_res( dict_of_input, dict_of_output, i, cirrus_working) result[bands_definition.ListOfL2Resolution[i]] = res_result l_gammamean = l_gammamean + res_result[3] * res_result[4] l_nbgamma = l_nbgamma + res_result[3] l_gammamean = l_gammamean / l_nbgamma l_gamma_max = float( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionMaxGammaValue")) l_gamma_min = float( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionMinGammaValue")) # Boundary set for gamma if l_gammamean > l_gamma_max: l_gammamean = l_gamma_max if l_gammamean < l_gamma_min: l_gammamean = l_gamma_min LOGGER.info("Gamma : " + str(l_gammamean)) # Apply correction for i in range(0, len(bands_definition.ListOfL2Resolution)): l_res = bands_definition.ListOfL2Resolution[i] corrected_toa = os.path.join(cirrus_working, "toac_" + l_res + ".tif") l_gammaswir = l_gammamean * float( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionSWIRGammaFactor")) l_l2bandcodes = bands_definition.get_list_of_l2_band_code( l_res) swir_band_list = xml_tools.as_string_list( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionSWIRBandCodes")) # Param of cirrus apply app param_cirrus_apply = { "l2toa": dict_of_output["AtmoAbsIPTOA_" + l_res], "l2edg": dict_of_input.get("L1Reader").get_value("L2EDGOutputList") [i], "l2dtm": dict_of_input.get("DEM").ALTList[i], "l2cirrus": result[l_res][0], "cirrusmask": result[l_res][1], "resolution": bands_definition.get_l1_resolution(l_res), "maxdistance": float( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionMaxDistance")), "thresholdgain": float( dict_of_input.get("L2COMM").get_value( "CirrusMaskThresholdGain")), "thresholdoffset": float( dict_of_input.get("L2COMM").get_value( "CirrusMaskThresholdOffset")), "thresholdfactor": float( dict_of_input.get("L2COMM").get_value( "CirrusCorrectionThresholdFactor")), "gammamean": l_gammamean, "swirgammafactor": l_gammaswir, "maxreflectance": float( dict_of_input.get("L2COMM").get_value( "CirrusMaxReflectance")), "bandcodelist": l_l2bandcodes, "swirbandcodelist": swir_band_list, "correctedtoa": corrected_toa } app = OtbAppHandler( "CirrusCorrectionApply", param_cirrus_apply, write_output=(False or is_croco_on("cirruscorrection"))) self._l2_pipeline.add_otb_app(app) dict_of_output["L2TOA_" + l_res] = app.getoutput().get("correctedtoa") else: LOGGER.info( "Cirrus flag disabled on reference resolution, no cirrus correction" ) # return cirrus corrected flag dict_of_output["CirrusCorrected"] = ref_result[2] return ref_result[2]
def generate_mask_rasters_gml(self, boundingBoxMap, l2Areas, projectionRef, satPixFileNames, defectivPixFileNames, zoneMaskFileNames, gdalRasterizeMaskCmd, gdalRasterizeDetCmd, working): """ :param boundingBoxMap: BoundingBoxMapType :param projectionRef: string :param satPixFileNames: ListOfStrings :param defectivPixFileNames: ListOfStrings :param zoneMaskFileNames: ListOfStrings :param gdalRasterizeMaskCmd: string :param gdalRasterizeDetCmd: string :param working: string :return: """ # ******************************************************************************************************* # Generate mask rasters by rasterizing the gml mask per L2 resolution per band # ******************************************************************************************************* LOGGER.debug("Start GML mask rasterization ...") l_BandsDefinitions = self._plugin.BandsDefinitions l2Area = None l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings l_NbL2Res = len(l_ListOfL2Resolution) for l2res in range(l_NbL2Res): self._l2defectmasklist.append([]) self._l2zonemasklist.append([]) self._l2satimagelist.append([]) for l2res in range(l_NbL2Res): # Current resolution: "R1" or "R2" curRes = l_ListOfL2Resolution[l2res] # Get the list of band of the current resolution listOfL2Bands = l_BandsDefinitions.get_list_of_l2_band_code(curRes) nbBand = len(listOfL2Bands) l2Area = l2Areas[l2res] counts = (0, 0, 0) # Generate a constant image that will be used if the gml masks are empty (no feature) tmp_constant_filename = os.path.join( working, "const_{}.tif:uint8".format(l2res)) tmp_constant_image_app = constant_image(self._dem.ALTList[l2res], 0, tmp_constant_filename, write_output=True) tmp_constant_image = tmp_constant_image_app.getoutput()["out"] # 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) LOGGER.debug( "Sentinel2L1ImageFileReaderBase::GenerateMaskRasters: CurrentResol = %s, reading the " "BandId L1 (associated) <%s> with index <%s>.", curRes, l_StrBandIdL2, l1BandIdx) # Read the bounding box for the resolution "l_L1Resolution" l_BoundingBox = boundingBoxMap.get(curRes) # =======> RASTERIZE GML MASKS new_counts = self.rasterize_gml_masks( curRes, l2res, l2Area, projectionRef, l1BandIdx, satPixFileNames[l1BandIdx], defectivPixFileNames[l1BandIdx], zoneMaskFileNames[l1BandIdx], l_BoundingBox, gdalRasterizeMaskCmd, gdalRasterizeDetCmd, tmp_constant_image, working) counts = tuple(map(operator.add, counts, new_counts)) # band loop # ******************************************************************************************************* # L2 Zone mask pipeline connection # ******************************************************************************************************* if counts[0] != 0: zone_mask = os.path.join(working, "Masks_Zone_{}.tif".format(l2res)) param_concatenate = { "il": self._l2zonemasklist[l2res], "out": zone_mask + ":uint8" } l2zoneimage_app = OtbAppHandler( "ConcatenateDoubleImages", param_concatenate, write_output=(False or is_croco_on("sentinel2.l1reader.l2zone"))) self._l2zoneimagelist.append( l2zoneimage_app.getoutput().get("out")) self._pipeline.add_otb_app(l2zoneimage_app) else: self._l2zoneimagelist.append(self._l2zonemasklist[l2res][0]) # ******************************************************************************************************* # PIX image pipeline connection (DEFECTIV PIX) # ******************************************************************************************************* if counts[2] != 0: # Compress (concatenate the vector image to binary image) pix_vector_mask = os.path.join( working, "Masks_Defect_Vector_{}.tif".format(l2res)) param_concatenate = { "il": self._l2defectmasklist[l2res], "out": pix_vector_mask + ":uint8" } pix_vector = OtbAppHandler("ConcatenateDoubleImages", param_concatenate) pix_mask = os.path.join(working, "Masks_Defect_{}.tif".format(l2res)) param_binconcatenate = { "im": pix_vector.getoutput().get("out"), "out": pix_mask + ":uint16" } pix = OtbAppHandler( "BinaryConcatenate", param_binconcatenate, write_output=(False or is_croco_on("sentinel2.l1reader.l2pix"))) self._pipeline.add_otb_app(pix) self._l2piximagelist.append(pix.getoutput().get("out")) else: self._l2piximagelist.append(self._l2defectmasklist[l2res][0]) # end res loop LOGGER.debug("End GML mask rasterization ...")
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 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 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 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 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