def generate_sat_images(self, working_dir): """ :return: """ # ******************************************************************************************************* # IPSAT Sub image pipeline connection # ******************************************************************************************************* out_concatenate = os.path.join(working_dir, "SubSatVector.tif") param_concatenate = {"il": self._satmasksublist, "out": out_concatenate + ":uint8" } concat_app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate) self._subsatimage = concat_app.getoutput().get("out") # ******************************************************************************************************* # L2SAT image pipeline connection # ******************************************************************************************************* l_BandsDefinitions = self._plugin.BandsDefinitions l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # At L2 resolution l_NbL2Res = len(l_ListOfL2Resolution) for i in range(l_NbL2Res): str_res = l_ListOfL2Resolution[i] out_concatenate = os.path.join(working_dir, "L2SATVector_{}.tif".format(str_res)) param_concatenate = {"il": self._l2satimagelist[i], "out": out_concatenate + ":uint8" } sat_image = OtbAppHandler("ConcatenateDoubleImages", param_concatenate, write_output=False) self._pipeline.add_otb_app(sat_image) self._l2satmasklist.append(sat_image.getoutput().get("out"))
def run(self, dict_of_input, dict_of_output): LOGGER.info("Rain detection computation start") rain_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "RainFlagProc_", do_always_remove=True) image_list = [ dict_of_output.get(constants.CLOUD_MASK_ALL_CLOUDS), dict_of_output.get("WaterMask") ] image_list.append( dict_of_input.get("L1Reader").get_value("IPEDGSubOutput")) image_list.append(dict_of_input.get("L2Reader").get_value("WASImage")) image_list.append(dict_of_input.get("L2Reader").get_value("NDTImage")) exp = "im1b1 || im2b1 || im3b1 || im4b1 || im5b1" or_all = os.path.join(rain_working, "OrAll.tif") if dict_of_input.get("Params").get("SnowBandAvailable"): image_list.append(dict_of_output.get("cld_snow")) exp = exp + " || im6b1" param_orall = {"il": image_list, "exp": exp, "out": or_all} orall_app = OtbAppHandler("BandMath", param_orall, write_output=False) tocr_extract = os.path.join(rain_working, "Tocr_Extract.tif") tocrextract_image_app = extract_roi( dict_of_output.get("RayleighIPTOCR"), [dict_of_input.get("Params").get("WaterBandIndex_DateD")], tocr_extract, write_output=False) rcr_extract = os.path.join(rain_working, "Rcr_Extract.tif") rcrextract_image_app = extract_roi( dict_of_input.get("L2Reader").get_value("RCRImage"), [dict_of_input.get("Params").get("WaterBandIndex_DateDm1")], rcr_extract, write_output=False) param_rcrstat = { "im": rcrextract_image_app.getoutput()["out"], "mask": orall_app.getoutput()["out"], } rcrstat_app = OtbAppHandler("Stats", param_rcrstat, write_output=False) rcr_mean = rcrstat_app.getoutput()["mean"] param_tocrstat = { "im": tocrextract_image_app.getoutput()["out"], "mask": orall_app.getoutput()["out"], } tocrstat_app = OtbAppHandler("Stats", param_tocrstat, write_output=False) tocr_mean = tocrstat_app.getoutput()["mean"] diffMean = rcr_mean - tocr_mean if diffMean > dict_of_input.get("L2COMM").get_value_f( "ReflectanceDecreaseThreshold"): dict_of_output["RainFlag"] = True else: dict_of_output["RainFlag"] = False
def write_qlt_product(self, p_res, p_qlt_image_filename, working_dir): LOGGER.info("EarthExplorerL2ImageFileWriter:WriteQLTproduct()") l_BandsDefinitions = self._plugin.BandsDefinitions l_StrRes = l_BandsDefinitions.ListOfL2Resolution[p_res] QOTHImageList = [] QOTHImageList.append(self._l2edgimagelist[p_res]) QOTHImageList.append(self._l2taomasklist[p_res]) if self._plugin.WaterVapourDetermination: QOTHImageList.append(self._l2iwcmasklist[p_res]) # Concat to get atb qoth_tmp_concat = os.path.join(working_dir, "tmp_qoth_" + l_StrRes + ".tif") param_qoth_concat = { "il": QOTHImageList, "out": qoth_tmp_concat + ":uint8" } qoth_concat_app = OtbAppHandler("ConcatenateDoubleImages", param_qoth_concat, write_output=False) qoth_tmp_binconcat = os.path.join(working_dir, "tmp_binqoth_" + l_StrRes + ".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_StrRes + ".tif") param_sat_binconcat = { "im": self._l2satimagelist[p_res], "out": sat_tmp_concat + ":uint8" } sat_binconcat_app = OtbAppHandler("BinaryConcatenate", param_sat_binconcat, write_output=False) # Create the QLT vector image QLTImageList = [] QLTImageList.append(sat_binconcat_app.getoutput().get("out")) QLTImageList.append(self._l2piximagelist[p_res]) QLTImageList.append(qoth_binconcat_app.getoutput().get("out")) param_qlt_concat = { "il": QLTImageList, "out": p_qlt_image_filename + ":uint8" } OtbAppHandler("ConcatenateDoubleImages", param_qlt_concat)
def clean_pipe(input_file_path): parameters = {"in": input_file_path, "startx": 0, "starty": 0, "sizex": 1, "sizey": 1, "out": "tmp.tif"} otb_app = OtbAppHandler("ExtractROI",parameters,write_output=False) parameters2 = {"im": otb_app.getoutput().get("out")} otb_app2 = OtbAppHandler("Stats", parameters2, write_output=True) LOGGER.debug("Stats on clean: "+str(otb_app2.getoutput().get("mean"))) del otb_app2 del otb_app
def run(self, dict_of_input, dict_of_output): LOGGER.info("Snow percentage computation start") param_stats = {"im": dict_of_output.get("cld_snow"), "exclude": 1} l2_stat = OtbAppHandler("Stats", param_stats) # Test on the value if (l2_stat.getoutput()["excludedcount"] == 0 and l2_stat.getoutput()["validcount"] == 0): l_snowrate = 0 else: l_snowrate = l2_stat.getoutput()["excludedcount"] * 100.0 / ( l2_stat.getoutput()["excludedcount"] + l2_stat.getoutput()["validcount"]) LOGGER.debug("L2 snowrate : " + str(l_snowrate)) dict_of_output["SnowRate"] = l_snowrate return l_snowrate
def run(self, dict_of_input, dict_of_output): LOGGER.info("Cirrus flag computation start") param_cirrus = { "cla": dict_of_output["CLA_Sub"], "edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"), "altthreshold": int(dict_of_input.get("L2COMM").get_value("AltitudeThreshold")), "minpercentcirrus": float(dict_of_input.get("L2COMM").get_value("MinPercentCirrus")), "minpercentcloud": float(dict_of_input.get("L2COMM").get_value("MinPercentCloud")), "minstdcirrus": float(dict_of_input.get("L2COMM").get_value("MinRstdCirrus")), "minpercentstdcirrus": float( dict_of_input.get("L2COMM").get_value("MinPercentStdCirrus")), "nodata": dict_of_input.get("L1Info").RealL1NoData } cirrus_mask_app = OtbAppHandler("CirrusFlag", param_cirrus, write_output=True) dict_of_output["CirrusFlag"] = cirrus_mask_app.getoutput( )["cirrusflag"] cirrus_mask_app = None
def generate_l2_sat_images(self, l_ListOfL2Resolution, working_dir): for l1res in range(len(l_ListOfL2Resolution)): curL1Res = l_ListOfL2Resolution[l1res] l_ListOfL2BandCode = self._plugin.BandsDefinitions.get_list_of_l2_band_code( curL1Res) dtm = self._dem.ALTList[0] tmp_constant_sat_filename = os.path.join( working_dir, "SAT_constant_image_{}.tif".format(l1res)) app_constant_sat_app = constant_image(dtm, 0, tmp_constant_sat_filename, write_output=False) self._sat_pipeline.add_otb_app(app_constant_sat_app) # ****************************************************************************************************** # L2 SAT image pipeline connection # ****************************************************************************************************** for band in l_ListOfL2BandCode: self._satmasklist.append( app_constant_sat_app.getoutput().get("out")) out_sat_concatenate = os.path.join( working_dir, "SATVectorImageList{}.tif".format(l1res)) param_concatenate_sat = { "il": self._satmasklist, "out": out_sat_concatenate + ":uint8" } concatenate_sat_app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate_sat, write_output=False) self._sat_pipeline.add_otb_app(concatenate_sat_app) # L2SAT self._l2satmasklist.append( concatenate_sat_app.getoutput().get("out"))
def get_solar_grids(self, dtm, solarAnglesFile, solH1, working): solar_grid_filename = os.path.join(working, "solar_grid.tif") # angle_list_to_image() solarangle_grid_app = angle_list_to_image(dtm, solarAnglesFile, solar_grid_filename, write_output=False) # Multiply by the solar reference altitude solar_grid_mult_filename = os.path.join(working, "solar_grid_mult.tif") param_scaled_solar = { "im": solarangle_grid_app.getoutput().get("out"), "coef": float(solH1), "out": solar_grid_mult_filename } rta_scal_app = OtbAppHandler("MultiplyByScalar", param_scaled_solar, write_output=False) # Expand at L2Coarse. solar_grid_resamp_filename = os.path.join(working, "solar_grid_resamp.tif") resample(rta_scal_app.getoutput().get("out"), dtm, solar_grid_resamp_filename, OtbResampleType.LINEAR) self._sol1image = solar_grid_resamp_filename
def generate_sol1_image(self, sol_h1, working_dir): const_pi_18 = math.pi / 180 sol_filename = os.path.join(working_dir, "sol1.tif") mean_solar = self._header_handler.get_mean_solar_angles() l_sol1 = sol_h1 * math.tan(const_pi_18 * mean_solar[0]) * math.sin( const_pi_18 * mean_solar[1]) l_sol2 = sol_h1 * math.tan(const_pi_18 * mean_solar[0]) * math.cos( const_pi_18 * mean_solar[1]) cla_app_1 = constant_image(self._dem.ALC, l_sol1, sol_filename, write_output=False) cla_app_2 = constant_image(self._dem.ALC, l_sol2, sol_filename, write_output=False) out_concatenate = os.path.join(working_dir, "sol1_concat.tif") param_concatenate = { "il": [ cla_app_1.getoutput().get("out"), cla_app_2.getoutput().get("out") ], "out": out_concatenate } app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate) self._sol1image = app.getoutput().get("out") self._sol1_pipeline.add_otb_app(app)
def write_cld_image(self, p_cldimages, p_clddatabandsselected, cld_image_filename, use_filenames=False): il = [] for c in p_clddatabandsselected: band = self._plugin.get_cld_algoindex_from_bandname(c) il.append(p_cldimages[band]) param_concat = {"il": il, "out": "tmp.tif:uint8"} if not use_filenames: concat_app = OtbAppHandler("ConcatenateMaskImages", param_concat, write_output=False) else: concat_app = OtbAppHandler("ConcatenateImages", param_concat, write_output=False) param_bin_concat = { "im": concat_app.getoutput().get("out"), "out": cld_image_filename + ":uint8" + file_utils.get_extended_filename_write_image_file_standard() } bin_concat_app = OtbAppHandler("BinaryConcatenate", param_bin_concat, write_output=True)
def get_ozone_amount(ozone_filename, corner): ozoneamount = 0.0 l_gribfilename = os.path.splitext(ozone_filename)[0] + ".DBL.BIN" if os.path.exists(l_gribfilename): LOGGER.info("Reading meteo file : " + l_gribfilename) param_app = { "im": l_gribfilename + "?&resol=7", "lat": corner.latitude, "lon": corner.longitude } app = OtbAppHandler("OzoneExtractor", param_app) ozoneamount = app.getoutput()["ozone"] # ------------------------------------------------------------------------------------ # Conversion from Kg/m2 to cm.atm (Dobson Unit/1000) # Note: # - 1 kg[O3]/m2 = 1/2.1416 x 10-5 = 46694.06 dobson # - 1 cm.atm = 1 jacobson = 1000 dobson # In the ozone file, the value is in 1 kg[O3]/m2. # The ozone value computed is in Jacobson (cm.atm/m2) l_dobsonconversionfactor = 46.694 ozoneamount = ozoneamount * l_dobsonconversionfactor LOGGER.debug( "OzoneAmountValue patched with the following Dobson conversion factor " + str(l_dobsonconversionfactor) + ".") return ozoneamount
def generate_vie_image(self, view_href, working_dir): const_pi_18 = math.pi / 180 vie_filename = os.path.join(working_dir, "vie.tif") mean_solar = self._header_handler.get_mean_solar_angles() l_vie1 = view_href * math.tan(const_pi_18 * mean_solar[0]) * math.sin( const_pi_18 * mean_solar[1]) l_vie2 = view_href * math.tan(const_pi_18 * mean_solar[0]) * math.cos( const_pi_18 * mean_solar[1]) app_1 = constant_image(self._dem.ALC, l_vie1, vie_filename, write_output=False) app_2 = constant_image(self._dem.ALC, l_vie2, vie_filename, write_output=False) out_concatenate = os.path.join(working_dir, "vie_concat.tif") param_concatenate = { "il": [app_1.getoutput().get("out"), app_2.getoutput().get("out")], "out": out_concatenate } app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate) self._vieimage.append(app.getoutput().get("out")) self._vie_pipeline.add_otb_app(app)
def generate_sat_sub_image(self, l2comm, working): # Sat are not provided on landsat 8 thus no need to resample or threshold anything, just create constant # images at coarse resolution dtm_coarse = self._dem.ALC l_ListOfCoarseBandCode = self._plugin.BandsDefinitions.get_list_of_band_id_in_l2_coarse( ) tmp_constant_sat_filename = os.path.join(working, "SATSub_constant_image.tif") app_constant_sat_app = constant_image(dtm_coarse, 0, tmp_constant_sat_filename + ":uint8", write_output=False) self._sat_sub_pipeline.add_otb_app(app_constant_sat_app) # ****************************************************************************************************** # Sub SAT image pipeline connection # ****************************************************************************************************** for band in l_ListOfCoarseBandCode: self._satsublist.append( app_constant_sat_app.getoutput().get("out")) # end band loop #concatenate const image to have the vector image with coarse nb bands sat_sub_image = os.path.join(working, "sat_sub.tif") param_concatenate = { "il": self._satsublist, "out": sat_sub_image + ":uint8" } app_concatenate = OtbAppHandler("ConcatenateMaskImages", param_concatenate) self._subsatimage = app_concatenate.getoutput().get("out") self._sat_sub_pipeline.add_otb_app(app_concatenate) self._sat_sub_pipeline.free_otb_app()
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 generate_toa_sub_image(self, working): dtm_coarse = self._dem.ALC # For each res of the input L1 product for i, toa in enumerate(self._l1toaimagelist): # undersampling at L2CoarseResolution toa_sub_image = os.path.join(working, "aot_sub_{}.tif".format(i)) app_resample = resample(toa, dtm_coarse, toa_sub_image, OtbResampleType.LINEAR_WITH_RADIUS, write_output=False) self._toa_sub_pipeline.add_otb_app(app_resample) self._toasublist.append(app_resample.getoutput().get("out")) # end res loop #concat toa_sub_image = os.path.join(working, "aot_sub.tif") param_concatenate = {"il": self._toasublist, "out": toa_sub_image} app_concatenate = OtbAppHandler("ConcatenateDoubleImages", param_concatenate, write_output=False) self._toa_sub_pipeline.add_otb_app(app_concatenate) #apply edg #invert EDG for masking out_edgsub_threshold = os.path.join(working, "edgsubthreshold.tif") param_edgsub_threshold = { "im": self._edgsubmask, "thresholdvalue": self._toathresholdminvalue, "equalvalue": 1, "outsidevalue": 0, "out": out_edgsub_threshold + ":uint8" } app_edgsub_threshold = OtbAppHandler("OneBandEqualThreshold", param_edgsub_threshold, write_output=False) self._toa_sub_pipeline.add_otb_app(app_edgsub_threshold) #apply mask to sub toa tmp_l2subtoa = os.path.join(working, "toasub.tif") app_l2subtoa = apply_mask(app_concatenate.getoutput().get("out"), app_edgsub_threshold.getoutput().get("out"), self._reall1nodata, tmp_l2subtoa, write_output=True) self._subtoaimage = app_l2subtoa.getoutput().get("out") self._toa_sub_pipeline.free_otb_app()
class MajaRayleighCorrection(MajaModule): """ classdocs """ NAME = "RayleighCorrection" def __init__(self): """ Constructor """ super(MajaRayleighCorrection, self).__init__() self._rayleigh_app = None self.in_keys_to_check = [ "Params.Caching", "AppHandler", "Plugin", "L1Reader", "L2COMM", "DEM", "L2TOCR", "Params.RealL2NoData" ] self.out_keys_to_check = ["AtmoAbsIPTOAC", "cr_lut"] self.out_keys_provided = ["RayleighIPTOCR"] def run(self, dict_of_input, dict_of_output): LOGGER.info("Rayleigh Correction start") caching = dict_of_input.get("Params").get("Caching") if caching: ray_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "RayleighProc_", do_always_remove=True) else: ray_working = "" tocr_image = os.path.join(ray_working, "tocr_sub.tif") param_rayleigh = { "lutimage": dict_of_output.get("cr_lut"), "lutheader": dict_of_input.get("L2TOCR"), "toa": dict_of_output.get("AtmoAbsIPTOAC"), "edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"), "dtm": dict_of_input.get("DEM").ALC, "nodata": dict_of_input.get("Params").get("RealL2NoData"), "defaultaot": float( dict_of_input.get("L2COMM").get_value( "RayleighCorrectionDefaultAOT")), "tocr": tocr_image } self._rayleigh_app = OtbAppHandler("RayleighCorrection", param_rayleigh, write_output=True) dict_of_output["RayleighIPTOCR"] = self._rayleigh_app.getoutput( )["tocr"]
def assign_zenith_and_azimuth_image_to_grid_to_image(input_image_zen, input_value_azi, output_filename): """ :param output_filename: :param input_image_zen: :param input_value_azi: :return: """ band_math_1 = OtbAppHandler("BandMath", {"il": [input_image_zen, input_value_azi], "exp": "tan(im1b1)*sin(im2b1)"}, write_output=False) pipeline = OtbPipelineManager() pipeline.add_otb_app(band_math_1) band_math_2 = OtbAppHandler("BandMath", {"il": [input_image_zen, input_value_azi], "exp": "tan(im1b1)*cos(im2b1)"}, write_output=False) pipeline.add_otb_app(band_math_2) concat = OtbAppHandler("ConcatenateImages", {"il": [band_math_1.getoutput().get( "out"), band_math_2.getoutput().get("out")], "out": output_filename}, write_output=True) pipeline.add_otb_app(concat) return pipeline
def generate_qb_mask(self, qb_filename, working_dir): img_binaryqb = os.path.join(working_dir, "NoDataFromQBFilter.tif") param_bintovec_qb = { "im": qb_filename, "out": img_binaryqb + ":uint8", "nbcomp": 16 } app = OtbAppHandler("BinaryToVector", param_bintovec_qb, write_output=False) self._toa_pipeline.add_otb_app(app) self._qbmask = app.getoutput().get("out") self._qb_pipeline.add_otb_app(app)
class MajaCloudMaskUndersampling(MajaModule): """ classdocs """ NAME = "CloudMaskUndersampling" def __init__(self): """ Constructor """ super(MajaCloudMaskUndersampling, self).__init__() self._undersampling_app = None def run(self, dict_of_input, dict_of_output): LOGGER.info("Cloud Mask Undersampling start") caching = dict_of_input.get("Params").get("Caching") cla_working = "" if caching: cla_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "CloudMaskUnderProc_", do_always_remove=True) l1_cla = dict_of_input.get("L1Reader").get_value("CLAImage") cla_image = os.path.join(cla_working, "cla_image_sub.tif") clalt_image = os.path.join(cla_working, "clalt_image_sub.tif") param_resamp_cla = { "dtm": dict_of_input.get("DEM").ALC, "im": l1_cla, "nodata": dict_of_input.get("L1Info").RealL1NoData, "cla": cla_image, "clalt": clalt_image } self._undersampling_app = OtbAppHandler("CloudMaskUndersampling", param_resamp_cla, write_output=caching) dict_of_output["CLA_Sub"] = self._undersampling_app.getoutput()["cla"] dict_of_output["CLALT_Sub"] = self._undersampling_app.getoutput( )["clalt"]
def run(self, dict_of_input, dict_of_output): LOGGER.info("Validity L2 nominal computation start") param_stats = { "im": dict_of_input.get("L2Reader").get_value("NDTImage"), "exclude": 1 } l2_stat = OtbAppHandler("Stats", param_stats) # Test on the value l_L2inNoDataRate = 0 if l2_stat.getoutput()["excludedcount"] == 0 and l2_stat.getoutput( )["validcount"] == 0: l_L2inNoDataRate = 0 else: l_L2inNoDataRate = l2_stat.getoutput()["excludedcount"] * 100.0 / \ (l2_stat.getoutput()["excludedcount"] + l2_stat.getoutput()["validcount"]) LOGGER.debug("L2 no data rate : " + str(l_L2inNoDataRate)) dict_of_output["L2inNoDataRate"] = l_L2inNoDataRate dict_of_output["L2inValidity"] = False if l_L2inNoDataRate > float( dict_of_input.get("L2COMM").get_value("MaxNoDataPercentage")): dict_of_output["L2inValidity"] = False else: dict_of_output["L2inValidity"] = True
def generate_sat_images(self, working_dir): """ :return: """ # ******************************************************************************************************* # IPSAT Sub image pipeline connection # ******************************************************************************************************* out_concatenate = os.path.join(working_dir, "SubSatVector.tif") param_concatenate = {"il": self._satmasksublist, "out": out_concatenate + ":uint8" } concat_app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate) self._subsatimage = concat_app.getoutput().get("out") self._sub_sat_pipeline.free_otb_app()
class MajaCirrusMaskComputation(MajaModule): """ classdocs """ NAME = "CirrusMask" def __init__(self): """ Constructor """ super(MajaCirrusMaskComputation, self).__init__() self._cirrus_mask_app = None self.in_keys_to_check = [ "AppHandler", "Plugin", "L1Reader","L2COMM", "DEM"] self.out_keys_to_check = [] self.out_keys_provided = ["CirrusFlag", "CirrusMask"] def run(self, dict_of_input, dict_of_output): LOGGER.info("Cirrus mask computation start") cirrus_working = dict_of_input.get("AppHandler").get_directory_manager().get_temporary_directory("CirrusMask_Computation_", do_always_remove=True) cirrus_mask = os.path.join(cirrus_working, "cirrus_mask_sub.tif") cirrus_band_code = dict_of_input.get("L2COMM").get_value("CirrusBandCode") bands_definition = dict_of_input.get("Plugin").BandsDefinitions cirrus_band_idx = bands_definition.get_band_id_in_l2_coarse(cirrus_band_code) param_cirrus = {"toa": dict_of_input.get("L1Reader").get_value("IPTOASubOutput"), "edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"), "dtm": dict_of_input.get("DEM").ALC, "bandidx": cirrus_band_idx, "threshoff": float(dict_of_input.get("L2COMM").get_value("CirrusMaskThresholdOffset")), "threshgain": float(dict_of_input.get("L2COMM").get_value("CirrusMaskThresholdGain")), "minpercent": float(dict_of_input.get("L2COMM").get_value("MinPercentMaskCirrus")), "altref" : float(dict_of_input.get("L2COMM").get_value("CirrusAltRef")), "mask": cirrus_mask + ":uint8" } self._cirrus_mask_app = OtbAppHandler("CirrusMask", param_cirrus, write_output=True) dict_of_output["CirrusMask"] = self._cirrus_mask_app.getoutput()["mask"] dict_of_output["CirrusFlag"] = self._cirrus_mask_app.getoutput()["cirrusflag"]
def generate_l1_toa_images(self, working_dir): """ :return: """ out_concatenate = os.path.join(working_dir, "L1TOAVector.tif") param_concatenate = { "il": self._toa_scalar_list, "out": out_concatenate } app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate, write_output=False) self._l1toa_pipeline.add_otb_app(app) self._l1toaimagelist.append(app.getoutput()["out"])
def generate_l1_toa_image(self, l2comm, factor, solzenith, L1ResolList, working_dir): for l1res in range(len(L1ResolList)): curL1Res = L1ResolList[l1res] l_ListOfL1BandCode = self._plugin.BandsDefinitions.get_list_of_l1_band_code( curL1Res) for band in l_ListOfL1BandCode: curMULT = self._header_handler.get_ref_mutl_factor_from_band_code( band) curADD = self._header_handler.get_ref_add_factor_from_band_code( band) expression_bandmath = "(im2b1 || (im1b1-0.00001)<0)?" + str( self._reall1nodata) + ":" if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")): expression_bandmath = expression_bandmath + str( factor) + "*" expression_bandmath = expression_bandmath + "(im1b1*" + str( curMULT) + "+" + str(curADD) + ")/cos(" + str( solzenith) + "*" + str(math.pi / 180) + ")" img_toaconverter = os.path.join( working_dir, "TOAConverter_{}.tif".format(band)) app_bandmath = band_math([ self._header_handler.get_toa_image_filename_from_band_code( band), self._qbmask ], expression_bandmath, img_toaconverter, write_output=False) self._toascalarlist.append(app_bandmath.getoutput().get("out")) self._toa_pipeline.add_otb_app(app_bandmath) img_concatenate_toa = os.path.join(working_dir, "l1toa_{}.tif".format(l1res)) param_concatenate_toa = { "il": self._toascalarlist, "out": img_concatenate_toa } app_concatenate_toa = OtbAppHandler("ConcatenateDoubleImages", param_concatenate_toa, write_output=True) self._l1toaimagelist.append(app_concatenate_toa.getoutput()["out"]) self._qb_pipeline.free_otb_app() self._toa_pipeline.free_otb_app()
def run(self, dict_of_input, dict_of_output): LOGGER.info("NoData percentage validity check start") param_stats = {"im": dict_of_output["Composite_ndt"], "exclude": 1} l2_stat = OtbAppHandler("Stats", param_stats) # Test on the value LOGGER.debug("L2Nodata : excludedcount : " + str(l2_stat.getoutput()["excludedcount"])) LOGGER.debug("L2Nodata : validcount : " + str(l2_stat.getoutput()["validcount"])) l_nodatarate = 0 if l2_stat.getoutput()["excludedcount"] == 0 and l2_stat.getoutput( )["validcount"] == 0: l_nodatarate = 0 else: l_nodatarate = l2_stat.getoutput()["excludedcount"] * 100.0 / \ (l2_stat.getoutput()["excludedcount"] + l2_stat.getoutput()["validcount"]) LOGGER.debug("L2 nodatarate : " + str(l_nodatarate)) dict_of_output["NoDataRate"] = l_nodatarate
def _dilate_and_mask(input, temp, output, mask, radius, caching): param_dilate = { "in": input, "out": temp + ":uint8", "structype": "ball", "xradius": radius, "yradius": radius, "filter": "dilate" } dilate_app = OtbAppHandler("BinaryMorphologicalOperation", param_dilate, write_output=caching) param_mask = { "il": [dilate_app.getoutput()["out"], mask], "out": output + ":uint8", "exp": "(im2b1 !=0)?0:im1b1" } mask_app = OtbAppHandler("BandMath", param_mask, write_output=caching) return mask_app
def generate_l2_toa_images(self, working_dir): """ :return: """ l_BandsDefinitions = self._plugin.BandsDefinitions l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings l_NbL2Res = len(l_ListOfL2Resolution) for l2res in range(l_NbL2Res): # Current resolution: "R1" or "R2" curRes = l_ListOfL2Resolution[l2res] dtm = self._dem.ALTList[l2res] # Get the list of band of the current resolution listOfL2Bands = l_BandsDefinitions.get_list_of_l2_band_code(curRes) nbBand = len(listOfL2Bands) list_of_image = [] # For each band of the current resolution for l_StrBandIdL2 in listOfL2Bands: # Get the L1 band index associated to the L2 band code l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_StrBandIdL2) # Generate the list of L2 TOA images per resolution toa_l2_image = os.path.join( working_dir, "aot_l2_{}.tif".format(l_StrBandIdL2)) app = resample(self._toa_scalar_list[l1BandIdx], dtm, toa_l2_image, OtbResampleType.LINEAR_WITH_RADIUS, write_output=False) self._toa_pipeline.add_otb_app(app) list_of_image.append(app.getoutput()["out"]) out_concatenate = os.path.join( working_dir, "L2TOAImageListVector_" + curRes + ".tif") param_concatenate = {"il": list_of_image, "out": out_concatenate} concat_app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate, write_output=False) self._toa_pipeline.add_otb_app(concat_app) self._l2toaimagelist.append(concat_app.getoutput().get("out"))
def run(self, dict_of_input, dict_of_output): LOGGER.info("Cloud percentage validity check start") param_stats = { "im": dict_of_output.get(CLOUD_MASK_ALL_CLOUDS), "exclude": 1 } l2_stat = OtbAppHandler("Stats", param_stats) # Test on the value LOGGER.debug("L2Cloud : excludedcount : " + str(l2_stat.getoutput()["excludedcount"])) LOGGER.debug("L2Cloud : validcount : " + str(l2_stat.getoutput()["validcount"])) LOGGER.debug("L2Cloud : nodatanumber : " + str(dict_of_output["L2NoDataNumber"])) l_cloudrate = 0 if l2_stat.getoutput()["excludedcount"] == 0 and l2_stat.getoutput( )["validcount"] == 0: l_cloudrate = 0 else: l_cloudrate = l2_stat.getoutput()["excludedcount"] * 100.0 / \ (l2_stat.getoutput()["excludedcount"] + l2_stat.getoutput()["validcount"] - dict_of_output["L2NoDataNumber"]) LOGGER.debug("L2 cloudrate : " + str(l_cloudrate)) dict_of_output["CloudRate"] = l_cloudrate
class MajaDTMProcessing(MajaModule): """ classdocs """ NAME = "DTMProcessing" def __init__(self): """ Constructor """ super(MajaDTMProcessing, self).__init__() self._solar_app = None self._dtm_app = None self.in_keys_to_check = [ "Params.Caching", "AppHandler", "Plugin", "L1Reader", "L2COMM", "DEM" ] self.out_keys_to_check = [] self.out_keys_provided = ["dtm_shd", "dtm_hid"] def run(self, dict_of_input, dict_of_output): LOGGER.info("DTMProcessing computation start") LOGGER.debug("Caching %s", dict_of_input.get("Params").get("Caching")) dtm_working = dict_of_input.get( "AppHandler").get_directory_manager().get_temporary_directory( "DTmProc_", do_always_remove=True) solar_imge = os.path.join(dtm_working, "solar_angle.tif") hid_imge = os.path.join(dtm_working, "dtm_hid.tif") shd_imge = os.path.join(dtm_working, "dtm_shd.tif") grid_ref_alt = dict_of_input.get( "Plugin").ConfigUserCamera.get_Algorithms( ).get_GRID_Reference_Altitudes() param_solar = { "sol1.in": dict_of_input.get("L1Reader").get_value("SOL1Image"), "sol1.h": grid_ref_alt.get_SOLH1(), "solhref": grid_ref_alt.get_SOLHRef(), "sol": solar_imge } if dict_of_input.get("Plugin").GRIDReferenceAltitudesSOL2GridAvailable: param_solar["sol2.in"] = dict_of_input.get("L1Reader").get_value( "SOL2Image") param_solar["sol2.h"] = grid_ref_alt.get_SOLH2() self._solar_app = OtbAppHandler("SolarAngle", param_solar, write_output=True) param_dtm = { "viedtm": dict_of_input.get("L1Reader").get_value("DTMVIEImage"), "edg": dict_of_input.get("L1Reader").get_value("IPEDGSubOutput"), "distthreshold": float(dict_of_input.get("L2COMM").get_value("DistanceThreshold")), "solhref": self._solar_app.getoutput().get("outhref"), "viehref": grid_ref_alt.get_VIEHRef(), "hid": hid_imge, "shd": shd_imge, "dtm": dict_of_input.get("DEM").ALC, "solar": self._solar_app.getoutput()["sol"] } self._dtm_app = OtbAppHandler("DTMProcessing", param_dtm, write_output=True) # Update global dict with new output dict_of_output["dtm_shd"] = self._dtm_app.getoutput()["shd"] dict_of_output["dtm_hid"] = self._dtm_app.getoutput()["hid"]