def generate_toa_caching(self, listOfTOAImageFileNames, reflectanceMultiplicationValues, working): """ :param listOfTOAImageFileNames: ListOfStrings :param reflectanceMultiplicationValues: ListOfDoubles :return: """ if len(reflectanceMultiplicationValues) != len( listOfTOAImageFileNames): raise MajaDataException( "Not the same number of band images and coefficients") # --------------------------------------------------------------- # Get the number of band with the number of TOA image files set in the input product directory l_NbBand = len(listOfTOAImageFileNames) # int # Convert the input jp2 images in tif for i in range(l_NbBand): toaFilename = listOfTOAImageFileNames[i] LOGGER.debug("Caching the <%s> image filename...", toaFilename) LOGGER.debug("Reflectance quantification value: %s", reflectanceMultiplicationValues[i]) # Initialize the TOA reader l_ImageFilename = os.path.join(working, "toaconverted_" + str(i) + ".tif") # extract_roi(toaFilename,[0],l_ImageFilename,working) app = multiply_by_scalar(toaFilename, reflectanceMultiplicationValues[i], output_image=l_ImageFilename, write_output=True) self._pipeline.add_otb_app(app) self._toa_scalar_list.append(app.getoutput()["out"])
def initialize(self, filename, working_dir, has_snow): file_hdr = os.path.splitext(filename)[0] + ".HDR" file_dbl = os.path.splitext(filename)[0] + ".DBL" file_dbldir = os.path.splitext(filename)[0] + ".DBL.DIR" LOGGER.info("AUX_REFDE2 filename: " + filename) # uncompress dbl uncompress_dbl_product(file_dbl) # DEM filenames provider list_of_file = os.listdir(file_dbldir) nbresol = 0 for f in list_of_file: if "_ALT" in f and "TIF" in os.path.splitext(f)[1]: nbresol = nbresol + 1 LOGGER.info("Nb resolution found " + str(nbresol)) self.initialize_res_list(nbresol) LOGGER.info( "DEMFilenamesProvider::Initialize. Nb resolution computed:" + str(len(self._resList))) for resol in self._resList: LOGGER.debug("DEMFilenamesProvider::Initialize. Prefix resol : " + resol) handler = EarthExplorerXMLFileHandler(file_hdr) list_of_dbl_files = handler.get_list_of_packaged_dbl_files(True, False) LOGGER.info("DEMFileNames found " + str(len(list_of_dbl_files)) + " files") for i in range(0, len(list_of_dbl_files)): if list_of_dbl_files[i].split('.TIF')[-1]: raise MajaDataException( "Wrong file extension detected. Delete the file: " + str(list_of_dbl_files[i])) # -------------------------------------- # Find the correct filename for fi in list_of_dbl_files: # LAIG - FA - MAC - 1610 - CNES # ../ CONTEXTES_ANOMALIES / TMA_VENUS_maccs_errors / 4398 / VE_TEST_AUX_REFDE2_BRASCHAT_0001.DBL.DIR / VE_TEST_AUX_REFDE2_BRASCHAT_0001_SLP.TIF # Extract the last value -> SLP # ../ CONTEXTES_ANOMALIES / TMA_VENUS_maccs_errors / 4398 / VE_TEST_AUX_REFDE2_BRASCHAT_0001.DBL.DIR / VE_TEST_AUX_REFDE2_BRASCHAT_0001_ALT_R1.TIF # Extract the last value -> ALT l_splitted = (os.path.splitext(os.path.basename(fi))[0]).split("_") l_lenghtlistfilenamename = len(l_splitted) # Extract the tow last values -> ex: 0001 _SLP or ALT_R1 l_keytype = l_splitted[-1] if l_lenghtlistfilenamename > 2: l_keytype = l_splitted[-2] + "_" + l_keytype # -------------------------------------- # Test if the filename is ALC if "ALC" in l_keytype: self.ALC = fi # -------------------------------------- # Test if the filename is MSK elif "MSK" in l_keytype: self.MSK = fi # -------------------------------------- # Test if the filename is ASC elif "ASC" in l_keytype: self.ASC = fi # -------------------------------------- # Test if the filename is SLC elif "SLC" in l_keytype: self.__SLCInternal = fi else: # -------------------------------------- # Lop under resolutions for res in self._resList: # -------------------------------------- # Test if the filename is SLP if "SLP" in l_keytype: if res in l_keytype: self.__SLPListInternal.append(fi) # -------------------------------------- # Test if the filename is ALT elif "ALT" in l_keytype: if res in l_keytype: self.ALTList.append(fi) # -------------------------------------- # Test if the filename is ASP elif "ASP" in l_keytype: if res in l_keytype: self.__ASPListInternal.append(fi) else: LOGGER.debug( "Unknown Filename and associated product type.") # endloop resol # -------------------------------------- # Check existent of ALC filename if not os.path.exists(self.ALC): raise MajaDataException("The ALC file '" + self.ALC + "' of the DTM doesn't exist !") # -------------------------------------- # Check existent of MSK filename if not os.path.exists(self.MSK): raise MajaDataException("The MSK file '" + self.MSK + "' of the DTM doesn't exist !") # -------------------------------------- # Check existent of SLC filename if not os.path.exists(self.__SLCInternal): raise MajaDataException("The SLC file '" + self.__SLCInternal + "' of the DTM doesn't exist !") else: LOGGER.debug("Starting multiply " + self.__SLCInternal + " * " + str(self._coeff)) self.SLC = os.path.join( working_dir, "Mul_" + os.path.basename(self.__SLCInternal)) self._apps.add_otb_app( multiply_by_scalar(self.__SLCInternal, self._coeff, output_image=self.SLC)) mtdat = GdalDatasetInfo(self.__SLCInternal) self.CoarseArea = Area() self.CoarseArea.size = mtdat.size self.CoarseArea.origin = mtdat.origin self.CoarseArea.spacing = mtdat.pixel_size LOGGER.debug("Done") # -------------------------------------- for resol in range(0, len(self._resList)): # -------------------------------------- # Check existent of SLP filename if not os.path.exists(self.__SLPListInternal[resol]): raise MajaDataException("One of the SLP file '" + self.__SLPListInternal[resol] + "' of the DTM doesn't exist !") else: LOGGER.debug("Starting multiply " + self.__SLPListInternal[resol] + " * " + str(self._coeff)) tmp = os.path.join( working_dir, "Mul_" + os.path.basename(self.__SLPListInternal[resol])) slp_mul_app = multiply_by_scalar(self.__SLPListInternal[resol], self._coeff, output_image=tmp, write_output=False) self._apps.add_otb_app(slp_mul_app) mtdat = GdalDatasetInfo(self.__SLPListInternal[resol]) l2area = Area() l2area.size = mtdat.size l2area.origin = mtdat.origin l2area.spacing = mtdat.pixel_size self.ProjRef = mtdat.dataset.GetProjectionRef() self.L2Areas.append(l2area) LOGGER.debug("Done") self.SLPList.append(slp_mul_app.getoutput().get("out")) # -------------------------------------- # Check existent of ALT filename if not os.path.exists(self.ALTList[resol]): raise MajaDataException("One of the ALT file '" + self.ALTList[resol] + "' of the DTM doesn't exist !") # -------------------------------------- # Check existent of ASP filename if not os.path.exists(self.__ASPListInternal[resol]): raise MajaDataException("One of the ASP file '" + self.__ASPListInternal[resol] + "' of the DTM doesn't exist !") else: LOGGER.debug("Starting multiply " + self.__ASPListInternal[resol] + " * " + str(self._coeff)) tmp = os.path.join( working_dir, "Mul_" + os.path.basename(self.__ASPListInternal[resol])) asp_mul_app = multiply_by_scalar(self.__ASPListInternal[resol], self._coeff, output_image=tmp, write_output=False) self._apps.add_otb_app(asp_mul_app) LOGGER.debug("Done") self.ASPList.append(asp_mul_app.getoutput().get("out")) # end loop resol LOGGER.debug(nbresol) l_cartoCode = xml_tools.get_only_value( handler.root, "//DEM_Information/Cartographic/Coordinate_Reference_System/Code", namespaces=handler.nss, check=True) l_geoCode = xml_tools.get_only_value( handler.root, "//DEM_Information/Geographic/Coordinate_Reference_System/Code", namespaces=handler.nss, check=True) if l_cartoCode is not None: self.ProjCode = l_cartoCode.text self.ProjType = "PROJECTED" elif l_geoCode is not None: self.ProjCode = l_geoCode.text self.ProjType = "GEOGRAPHIC" else: raise MajaDataException("Unknown DEM type") LOGGER.debug("DEM Projection Code: " + self.ProjCode) LOGGER.debug("DEM Projection Type: " + self.ProjType) self.Site = xml_tools.get_xml_string_value( handler.root, "//Specific_Product_Header/Instance_Id/Applicable_Site_Nick_Name", namespaces=handler.nss) if nbresol != 0: param_stats = {"im": self.ALTList[0]} stat_app = stats(self.ALTList[0]) self.ALT_Mean = stat_app.getoutput().get("mean") self.ALT_Max = stat_app.getoutput().get("max") self.ALT_Min = stat_app.getoutput().get("min") self.ALT_Stdv = stat_app.getoutput().get("stdv") self.ALT_LogicalName = "LOCAL=" + os.path.splitext( os.path.basename(file_hdr))[0] LOGGER.info("DEM Mean : " + str(self.ALT_Mean)) LOGGER.info("DEM Max : " + str(self.ALT_Max)) LOGGER.info("DEM Min : " + str(self.ALT_Min)) LOGGER.info("DEM Stdv : " + str(self.ALT_Stdv))
def write_private_images( self, p_L2PrivateImageFilenamesProvider, p_ReflectanceQuantificationValue, p_CLDDataBandsSelected, p_CLDCoreAlgorithmsMapBand, p_WriteOnlyCLACLD, p_WriteLTC, working_dir): LOGGER.debug("Write LTC: " + str(p_WriteLTC)) LOGGER.debug("Write WriteOnlyCLACLD: " + str(p_WriteOnlyCLACLD)) LOGGER.debug("p_L2PrivateImageFilenamesProvider.GetLTCImageDirFileName(): %s", p_L2PrivateImageFilenamesProvider.get_ltc_image_dir_filename()) if not p_WriteOnlyCLACLD: # ** ** PRIVATE DATA ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** # START WRITING PXD Image file DATA # Create the writer # Initialize the writer filter otb_file_utils.otb_copy_image_to_file( self._pxd, p_L2PrivateImageFilenamesProvider.get_pxd_image_filename() + file_utils.get_extended_filename_write_image_file_standard()) # START WRITING WAM Image file DATA # Create the concatenate imagefilter # Create the writer UnsignedIntegerVectorImageFileWriterPointer # Convert Binary PWA and TWA images tmp_pwa_concat = os.path.join(working_dir, "tmp_pwa_concat.tif") param_pwa_concat = {"im": self._possiblewatermask, "out": tmp_pwa_concat } pwa_concat_app = OtbAppHandler("BinaryConcatenate", param_pwa_concat, write_output=False) tmp_twa_concat = os.path.join(working_dir, "tmp_twa_concat.tif") param_twa_concat = {"im": self._testedwatermask, "out": tmp_twa_concat } twa_concat_app = OtbAppHandler("BinaryConcatenate", param_twa_concat, write_output=False) # Concatenate into one file param_wam_concat = { "il": [ self._wasimage, pwa_concat_app.getoutput().get("out"), twa_concat_app.getoutput().get("out")], "out": p_L2PrivateImageFilenamesProvider.get_wam_image_filename() + ":uint16"+ file_utils.get_extended_filename_write_image_file_standard()} OtbAppHandler("ConcatenateImages", param_wam_concat) # START WRITING STO Image file DATA # Scalar filter multiply_by_scalar(self._sto,p_ReflectanceQuantificationValue, p_L2PrivateImageFilenamesProvider.get_sto_image_filename() + file_utils.get_extended_filename_write_image_file_standard() + ":int16") # START WRITING NDT Image file DATA # Create the writer # Evol 4 - 1: NDT ecris sur 8 bits(et non 16 bits car seuilement un masque) otb_file_utils.otb_copy_image_to_file( self._ndt, p_L2PrivateImageFilenamesProvider.get_ndt_image_filename() + file_utils.get_extended_filename_write_image_file_standard()) # START WRITING LTC Image file DATA # Create the image list if p_WriteLTC: otb_file_utils.otb_copy_image_to_file(self._ltc_image, p_L2PrivateImageFilenamesProvider.get_ltc_image_filename()) # START WRITING RTA Image file DATA multiply_by_scalar(self._rta, p_ReflectanceQuantificationValue, p_L2PrivateImageFilenamesProvider.get_rta_image_filename() + file_utils.get_extended_filename_write_image_file_standard()+":int16") # START WRITING RTC Image file DATA multiply_by_scalar(self._rtc, p_ReflectanceQuantificationValue, p_L2PrivateImageFilenamesProvider.get_rtc_image_filename() + file_utils.get_extended_filename_write_image_file_standard()+":int16") # START WRITING RCR Image file DATA multiply_by_scalar(self._rcr, p_ReflectanceQuantificationValue, p_L2PrivateImageFilenamesProvider.get_rcr_image_filename() + file_utils.get_extended_filename_write_image_file_standard()+":int16") # End od condition self.write_cld_image( self._cld, p_CLDDataBandsSelected, p_L2PrivateImageFilenamesProvider.get_cld_image_filename(), use_filenames=True) # ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** # START WRITING CLA Sub Image file DATA # ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** # LAIG - DM - MAC - 1691 - CNES: Write CLA only is available(only for VENUS - stereo) if self._cld_l2cla is not None: otb_file_utils.otb_copy_image_to_file( self._cld_l2cla, p_L2PrivateImageFilenamesProvider.get_cla_image_filename() + file_utils.get_extended_filename_write_image_file_standard())
def generate_vie_image(self, view_href, working_dir): LOGGER.debug("VenusMuscateL1ImageFileReader::GenerateVIEImage()") # ********************************************************************************************************* # VIE image pipeline connection # Get the VIE filename from the muscate xml l_D01_DX_ImageFileName = self._header_handler.get_vie_image_filename( "01", "DX") LOGGER.debug(l_D01_DX_ImageFileName) l_D01_DY_ImageFileName = self._header_handler.get_vie_image_filename( "01", "DY") LOGGER.debug(l_D01_DY_ImageFileName) l_D04_DX_ImageFileName = self._header_handler.get_vie_image_filename( "04", "DX") LOGGER.debug(l_D04_DX_ImageFileName) l_D04_DY_ImageFileName = self._header_handler.get_vie_image_filename( "04", "DY") LOGGER.debug(l_D04_DY_ImageFileName) # -------------------------------------- # VIE Expand image to the L2 Coarse resolution # Multiply by spacing since it is in m/m vie5b1_mult_filename = os.path.join(working_dir, "vie5b1_mult.tif") vie5b1_mult_app = multiply_by_scalar(l_D01_DX_ImageFileName, self._dem.L2Areas[0].spacing[0], vie5b1_mult_filename, write_output=False) vie5b2_mult_filename = os.path.join(working_dir, "vie5b1_mult_DX.tif") vie5b2_mult_app = multiply_by_scalar(l_D01_DY_ImageFileName, -1 * self._dem.L2Areas[0].spacing[1], vie5b2_mult_filename, write_output=False) vie6b1_mult_filename = os.path.join(working_dir, "vie6b1_mult.tif") vie6b1_mult_app = multiply_by_scalar(l_D04_DX_ImageFileName, self._dem.L2Areas[0].spacing[0], vie6b1_mult_filename, write_output=False) vie6b2_mult_filename = os.path.join(working_dir, "vie6b1_mult_DX.tif") vie6b2_mult_app = multiply_by_scalar(l_D04_DY_ImageFileName, -1 * self._dem.L2Areas[0].spacing[1], vie6b2_mult_filename, write_output=False) # Concatenate to get the final VIE out_concatenate = os.path.join(working_dir, "vie_concat.tif") param_concatenate = { "il": [ vie5b1_mult_app.getoutput().get("out"), vie5b2_mult_app.getoutput().get("out"), vie6b1_mult_app.getoutput().get("out"), vie6b2_mult_app.getoutput().get("out") ], "out": out_concatenate } concat_app = OtbAppHandler("ConcatenateDoubleImages", param_concatenate, write_output=False) LOGGER.debug("Start DTMVIEExpand ...") out_resample = os.path.join(working_dir, "vie_concat_resamp.tif") resamp_app = resample(concat_app.getoutput().get("out"), self._dem.ALC, out_resample, OtbResampleType.LINEAR, padradius=4, write_output=True) LOGGER.debug("DTMVIEExpand Done") self._vieimagelist.append(resamp_app.getoutput().get("out")) # ********************************************************************************************************* # VIE SHAD image pipeline connection # ********************************************************************************************************* out_shad_concatenate = os.path.join(working_dir, "vie_concat.tif") param_shad_concatenate = { "il": [l_D01_DX_ImageFileName, l_D01_DY_ImageFileName], "out": out_shad_concatenate } concat_shad_app = OtbAppHandler("ConcatenateDoubleImages", param_shad_concatenate, write_output=False) LOGGER.debug("Start DTMSHADExpand ...") out_shad_resample = os.path.join(working_dir, "vieshadconcat_resamp.tif") resamp_shad_app = resample(concat_shad_app.getoutput().get("out"), self._dem.ALC, out_shad_resample, OtbResampleType.LINEAR, padradius=4, write_output=True) LOGGER.debug("DTMSHADExpand Done") self._vieimagelist.append(resamp_shad_app.getoutput().get("out"))
def 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]