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("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 read(self, product_info, app_handler, l2comm, dem, pReadL1Mode):
"""product_info,plugin, l2comm,mode
:param product_info: L1ImageInformationsBase
:param pReadL1Mode: ReadL1ModeType
:return:
"""
product_filename = product_info.HeaderFilename
working_dir = app_handler.get_directory_manager(
).get_temporary_directory("L1Read_", do_always_remove=True)
self._plugin.initialize(app_handler)
self._GIPPL2COMMHandler = l2comm
LOGGER.info("Start Sentinel2 L1 ImageFileReader ...")
self._ReadL1Mode = pReadL1Mode
self._dem = dem
# --------------------------------------
# Check the extension of th efile. For Muscate, must be .XML (in upper case)
IsValidSatellite = (product_info.HeaderHandler is not None)
if not IsValidSatellite:
raise MajaPluginSentinel2Exception(
"The file <{}> is not a valid Sentinel2 L1 product.".format(
product_filename))
# Check the validity with the schema
lSchemaLocationFile = os.path.join(
app_handler.get_schemas_root_install_dir(),
self._plugin.MAJA_INSTALL_SCHEMAS_L1PRODUCT_FILE)
if app_handler.get_validate_schemas():
# remplacer par un appel à pylint ? un check xml
result = check_xml(product_filename, xsd_file=lSchemaLocationFile)
if not result:
raise MajaPluginSentinel2Exception(
"The xml file <{}> is not conform with its schema <{}> !, Log of execution :{}"
.format(product_filename, lSchemaLocationFile,
str(result)))
# --------------------------------------
# Load the header tile file in the xml tile handler to read tile information
xmlTileFilename = product_info.xmlTileFilename
# *******************************************************************************************************
# TOA & masks Reader connection
# *******************************************************************************************************
l_BandsDefinitions = self._plugin.BandsDefinitions # BandsDefinitions
l_ListOfTOAImageFileNames = product_info.HeaderHandler.get_list_of_toa_images(
) # ListOfStrings
l_SatPixFileNames = product_info.TileHandler.ListOfSaturatedPixelsHeaderFileName # ListOfStrings
l_DefectivPixFileNames = product_info.TileHandler.ListOfDefectivPixelsHeaderFileName # ListOfStrings
l_ZoneMaskFileNames = product_info.TileHandler.ListOfDetFootPrintHeaderFileName # ListOfStrings
l_NoDataMaskFileNames = product_info.TileHandler.ListOfNoDataPixelsHeaderFileName # ListOfStrings
l_ListOfTOABandCode = product_info.HeaderHandler.get_list_of_band_codes(
) # ListOfStrings
l_ListOfL1Resolution = l_BandsDefinitions.ListOfL1Resolution # ListOfStrings
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
l_NbL1Res = len(l_ListOfL1Resolution) # int
l_NbL2Res = len(l_ListOfL2Resolution) # int
l_NbBand = len(l_ListOfTOAImageFileNames) # int
# TODO: check ConfigUserCameraXMLFileHandler
# TODO; check GetL2CoarseResolution grep L2CoarseResolution
l_Areas = dem.L2Areas
l_L2CoarseArea = dem.CoarseArea
l_L2CoarseResolution = int(round(dem.CoarseArea.spacing[0]))
LOGGER.debug(l_L2CoarseResolution)
l_L1NoData = product_info.L1NoData
l_ReflectanceQuantificationValue = product_info.ReflectanceQuantification
l_RealL1NoData = l_L1NoData * l_ReflectanceQuantificationValue # RealNoDataType
if (len(l_ListOfTOABandCode) != len(l_ListOfTOAImageFileNames)) or (
len(l_ListOfTOABandCode) != len(l_SatPixFileNames)) or (
len(l_ListOfTOABandCode) != len(l_DefectivPixFileNames)):
raise MajaPluginSentinel2Exception(
"Sentinel2L1ImageFileReader.CanRead: Internal error: The number of image file, sat file and band code are different !"
)
# =======> GENERATE TOA CACHING
#
# * Get calibration coeffs if activated
l_reflectanceMultiplicationValues = [] # ListOfDoubles
if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")):
l_factors = xml_tools.as_float_list(
l2comm.get_value("CalAdjustFactor"))
if len(l_factors) != len(l_ListOfTOABandCode):
raise MajaPluginSentinel2Exception(
"Not the same number of Calibration coeffs than L1 bands ( {}, {} )"
.format(len(l_factors), len(l_ListOfTOABandCode)))
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue * l_factors[i])
else:
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue)
l_ProjectionRef = self._dem.ProjRef
self.generate_toa(l_ListOfTOAImageFileNames,
l_reflectanceMultiplicationValues,
working_dir) # string
# ***********************************************************************************************************
# Generate EDG at L2coarse and L2 resolutions
# ***********************************************************************************************************
self.generate_edg_images_from_toa(l_ListOfTOAImageFileNames,
working_dir)
# ***********************************************************************************************************
# Get the bounding box of each L1 resolution
# ***********************************************************************************************************
# list of bounding box per resolution
l_L1BoundingBoxMap = {} # BoundingBoxMapType
for res in range(l_NbL1Res):
curRes = l_ListOfL1Resolution[res] # string
l_IntResolution = l_BandsDefinitions.get_l1_resolution(curRes)
# Read the bounding box for the current resolution
l_BoundingBox = product_info.TileHandler.get_geoposition_boundingbox(
l_IntResolution) # BoundingBoxType
LOGGER.debug(
"S2 Geoposition BoundingBox computed: xmin, ymin, xmax, ymax: %s, %s, %s, %s.",
l_BoundingBox.xmin, l_BoundingBox.ymin, l_BoundingBox.xmax,
l_BoundingBox.ymax)
# Store the bounding box per resolution
l_L1BoundingBoxMap[curRes] = l_BoundingBox
# ***********************************************************************************************************
# ***********************************************************************************************************
# ***********************************************************************************************************
# START READ L1 for ALGORITHMS
# ***********************************************************************************************************
# ***********************************************************************************************************
# ***********************************************************************************************************
if pReadL1Mode == ReadL1Mode.READ_L1_MODE_FOR_ALGORITHMS:
# --------------------------------------
# Get information of areas (footprint) of the product (Origin, Spacing and Size for L2 and L2Coarse resolution)
# --------------------------------------
l_L2Dems = dem.ALTList
l_CoarseDem = dem.ALC
# ***********************************************************************************************************
# Get the bounding box of each L1 resolution
# ***********************************************************************************************************
# list of bounding box per resolution
l_L2CoarseBoundingBoxMap = {} # BoundingBoxMapType
for res in range(l_NbL1Res):
curRes = l_ListOfL1Resolution[res] # string
l_IntResolution = l_BandsDefinitions.get_l1_resolution(curRes)
l_PointXY = product_info.TileHandler.get_geoposition_upperleftcorner(
l_IntResolution) # PointXYType
l_L2CoarseBoundingBox = BoundingBox()
# ATTENTION: For coordinates, cf. FD 73233
l_L2CoarseBoundingBox.xmin = l_PointXY.x
l_L2CoarseBoundingBox.ymin = l_PointXY.y - l_L2CoarseArea.size[
1] * l_L2CoarseResolution
l_L2CoarseBoundingBox.xmax = l_PointXY.x + l_L2CoarseArea.size[
0] * l_L2CoarseResolution
l_L2CoarseBoundingBox.ymax = l_PointXY.y
l_L2CoarseBoundingBoxMap[curRes] = l_L2CoarseBoundingBox
LOGGER.debug("Start SubSampling ...")
# =======> GENERATE TOA SUB IMAGES AT L2 COARSE RESOLUTION
self.generate_toa_sub_images(working_dir)
LOGGER.debug("Start SubSampling done.")
# *******************************************************************************************************
# L2 TOA image pipeline connection
# ******************* ************************************************************************************
# =======> GENERATE L2 TOA IMAGES
self.generate_l2_toa_images(working_dir)
# *******************************************************************************************************
# Rasterize the gml mask per L2 resolution per band
# *******************************************************************************************************
# =======> GENERATE MASK RASTERS
self.generate_mask_rasters_gml(
l_L1BoundingBoxMap, l_Areas, l_ProjectionRef,
l_SatPixFileNames, l_DefectivPixFileNames, l_ZoneMaskFileNames,
self._plugin.
GDAL_RASTERIZE_GML_MASK_ADDITIONAL_COMMAND_LINE_PARAMETERS,
self._plugin.
GDAL_RASTERIZE_GML_DETECTOR_ADDITIONAL_COMMAND_LINE_PARAMETERS,
working_dir)
l_CurrentConfigUserCamera = self._plugin.ConfigUserCamera
grid_ref_alt = l_CurrentConfigUserCamera.get_Algorithms(
).get_GRID_Reference_Altitudes()
l_VIEHRef = grid_ref_alt.get_VIEHRef() # double
l_SOLH1 = grid_ref_alt.get_SOLH1() # double
# *******************************************************************************************************
# IPSOL Sub image pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start IPSOL SubSampling ...")
l_solarAngleFile = product_info.TileHandler.angles.sun_angles.write(
working_dir)
# =======> GENERATE SOLAR ANGLE GRIDS
self.get_solar_grids(self._dem.ALC, l_solarAngleFile, l_SOLH1,
working_dir)
LOGGER.debug("Start IPSOL SubSampling done.")
# *******************************************************************************************************
# IPVIE Sub image pipeline connection
# *******************************************************************************************************
LOGGER.debug("Start IPVIE SubSampling ...")
LOGGER.debug("For each band ...")
for l_band in range(l_NbBand):
l_L1Resolution = l_BandsDefinitions.get_l1_resolution_for_band_code(
l_ListOfTOABandCode[l_band]) # string
# Get the list of detectors (index)
l_ListOfZone = product_info.TileHandler.get_list_of_zones(
l_band) # ListOfUIntegers
l_BoundingBox = l_L2CoarseBoundingBoxMap[
l_L1Resolution] # BoundingBoxType
# Get the list of viewing angles in the header file of the tile
l_vieAngles = product_info.TileHandler.angles.viewing_incidence_angle.get_viewing_angles(
l_band) # ListOfListOfStrings
if len(l_vieAngles) == 0:
raise MajaPluginSentinel2Exception(
"No viewing angles for band " + str(l_band))
# =======> GENERATE VIEWING ANGLE GRIDS
self.get_viewing_grids(
l_band, l_L2CoarseArea, l_ProjectionRef, l_VIEHRef,
l_SatPixFileNames[l_band], l_ZoneMaskFileNames[l_band],
l_NoDataMaskFileNames[l_band], l_ListOfZone, l_BoundingBox,
l_vieAngles, self._plugin.
GDAL_RASTERIZE_GML_MASK_ADDITIONAL_COMMAND_LINE_PARAMETERS,
self._plugin.
GDAL_RASTERIZE_GML_DETECTOR_ADDITIONAL_COMMAND_LINE_PARAMETERS,
self._plugin.
GDAL_RASTERIZE_GML_NODATA_ADDITIONAL_COMMAND_LINE_PARAMETERS,
l_NbBand, working_dir)
LOGGER.debug("Start IPVIE SubSampling done.")
# To check mean angle values
# TODO: TBD
# zones = self.m_ViewingZenithMeanMap.keys()
# values = zip(zones,
# [self.m_ViewingZenithMeanMap.get(zone) for zone in zones],
# [self.m_ViewingAzimuthMeanMap.get(zone) for zone in zones])
# for zone, zenith, azimuth in values:
# LOGGER.debug(" Mean for zone %s is [zen;azi] : [%s;%s].", zone, zenith, azimuth)
# *******************************************************************************************************
# IPEDGSub and L2EDG pipeline connection
# *******************************************************************************************************
# *******************************************************************************************************
# IPSAT Sub and L2SAT image pipeline connection
# *******************************************************************************************************
# =======> GENERATE SAT IMAGES
self.generate_sat_images(working_dir)
# *******************************************************************************************************
# CLA image pipeline connection
# *******************************************************************************************************
# =======> GENERATE CLA IMAGES
self.generate_cla_images(l_RealL1NoData, working_dir)
# Fill the datas
self.dict_of_vals["IPEDGSubOutput"] = self._edgsubmask
self.dict_of_vals["SOL1Image"] = self._sol1image
l_DTMBandCode = xml_tools.as_string_list(
l2comm.get_value("DTMViewingDirectionBandCode"))[0]
l_DTMBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_DTMBandCode)
LOGGER.info("DTMBandCode= " + l_DTMBandCode)
self.dict_of_vals["DTMVIEImage"] = self._vieimagelist[l_DTMBandIdx]
self.dict_of_vals["IPTOASubOutput"] = self._sub_toa
self.dict_of_vals["L2TOAImageList"] = self._l2toaimagelist
self.dict_of_vals["ViewingZenithMeanMap"] = self._meanZenithMap
self.dict_of_vals["ViewingAzimuthMeanMap"] = self._meanAzimuthMap
self.dict_of_vals["CLAImage"] = self._claimage
self.dict_of_vals["IPSATSubOutput"] = self._subsatimage
l_CLDBandCode = l2comm.get_value("CLDViewingDirectionBandCode")
l_CLDBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CLDBandCode)
self.dict_of_vals["ShadowVIEImage"] = self._vieimagelist[
l_CLDBandIdx]
l_CirrusBandCode = l2comm.get_value("CirrusBandCode")
l_CirrusBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CirrusBandCode)
self.dict_of_vals["L1TOACirrusImage"] = self._toa_scalar_list[
l_CirrusBandIdx]
self.dict_of_vals["AngleZoneMaskList"] = self._l2zoneimagelist
self.dict_of_vals["L2EDGOutputList"] = self._l2edgmasklist
self.dict_of_vals["L2SATImageList"] = self._l2satmasklist
self.dict_of_vals["L2PIXImageList"] = self._l2piximagelist
def read(self, product_info, app_handler, l2comm, dem, pReadL1Mode):
"""product_info,plugin, l2comm,mode
:param product_info: L1ImageInformationsBase
:param pReadL1Mode: ReadL1ModeType
:return:
"""
LOGGER.info("Start Sentinel2Muscate L1 ImageFileReader ...")
product_filename = product_info.HeaderFilename
LOGGER.info(
"Start Sentinel2Muscate L1 ImageFileReader with filename : " +
product_filename)
working_dir = app_handler.get_directory_manager(
).get_temporary_directory("L1Read_", do_always_remove=True)
self._plugin.initialize(app_handler)
self._GIPPL2COMMHandler = l2comm
LOGGER.info("Start Sentinel2Muscate L1 ImageFileReader ...")
self._ReadL1Mode = pReadL1Mode
self._dem = dem
# --------------------------------------
# Check the extension of th efile. For Muscate, must be .XML (in upper case)
IsValidSatellite = (product_info.HeaderHandler is not None)
if not IsValidSatellite:
raise MajaExceptionPluginSentinel2Muscate(
"The file <{}> is not a valid Sentinel2 L1 product.".format(
product_filename))
self.m_headerHandler = product_info.HeaderHandler
# Get satellite name
self.m_Satellite = product_info.Satellite
# --------------------------------------
# Load the header tile file in the xml tile handler to read tile information
xmlTileFilename = product_info.xmlTileFilename
l_BandsDefinitions = self._plugin.BandsDefinitions # BandsDefinitions
# TOA & masks Reader connection
l_ListOfTOAImageFileNames = product_info.HeaderHandler.get_list_of_toa_image_filenames(
)
l_SatPixFileNames = product_info.HeaderHandler.get_list_of_l1_sat_image_filenames(
)
l_DefectivPixFileNames = product_info.HeaderHandler.get_list_of_defective_pixel_image_filenames(
)
l_ZoneMaskFileNames = product_info.HeaderHandler.get_map_list_of_detector_footprint_image_filenames(
)
l_NoDataMaskFileNames = product_info.HeaderHandler.get_list_of_l1_ndt_image_filenames(
)
l_ListOfTOABandCode = product_info.HeaderHandler.get_list_of_band_code(
) # ListOfStrings
l_NbBand = len(l_ListOfTOAImageFileNames) # int
l_L1NoData = product_info.L1NoData
l_ReflectanceQuantificationValue = product_info.ReflectanceQuantification
l_RealL1NoData = l_L1NoData * l_ReflectanceQuantificationValue # RealNoDataType
if (len(l_ListOfTOABandCode) != len(l_ListOfTOAImageFileNames)) or (
len(l_ListOfTOABandCode) != len(l_SatPixFileNames)) or (
len(l_ListOfTOABandCode) != len(l_DefectivPixFileNames)):
raise MajaExceptionPluginSentinel2Muscate(
"Sentinel2L1ImageFileReader.CanRead: Internal error: The number of image file, sat file and band code are different !"
)
# =======> GENERATE TOA
# Get calibration coeffs if activated
l_reflectanceMultiplicationValues = [] # ListOfDoubles
if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")):
l_factors = xml_tools.as_float_list(
l2comm.get_value("CalAdjustFactor"))
if len(l_factors) != len(l_ListOfTOABandCode):
raise MajaDataException(
"Not the same number of Calibration coeffs than L1 bands ( {}, {} )"
.format(len(l_factors), len(l_ListOfTOABandCode)))
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue * l_factors[i])
else:
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue)
l_ProjectionRef = self._dem.ProjRef
self.generate_toa(l_ListOfTOAImageFileNames,
l_reflectanceMultiplicationValues,
working_dir) # string
# START READ L1 for ALGORITHMS
if pReadL1Mode == ReadL1Mode.READ_L1_MODE_FOR_ALGORITHMS:
# =======> GENERATE TOA SUB IMAGES AT L2 COARSE RESOLUTION
LOGGER.debug("Start SubSampling ...")
self.generate_toa_sub_images(working_dir)
LOGGER.debug("Start SubSampling done.")
# the gml mask per L2 resolution per band
self.generate_mask_rasters(l_SatPixFileNames,
l_DefectivPixFileNames,
l_ZoneMaskFileNames,
l_NoDataMaskFileNames,
l_ListOfTOABandCode, working_dir)
LOGGER.debug("Filenames Mask Rasters : ")
LOGGER.debug(l_SatPixFileNames)
LOGGER.debug(l_DefectivPixFileNames)
LOGGER.debug(l_ZoneMaskFileNames)
LOGGER.debug(l_NoDataMaskFileNames)
LOGGER.debug(l_ListOfTOABandCode)
# Get the ref altitude
l_CurrentConfigUserCamera = self._plugin.ConfigUserCamera
grid_ref_alt = l_CurrentConfigUserCamera.get_Algorithms(
).get_GRID_Reference_Altitudes()
l_VIEHRef = grid_ref_alt.get_VIEHRef() # double
l_SOLH1 = grid_ref_alt.get_SOLH1() # double
# IPSOL Sub image pipeline connection
LOGGER.debug("Start IPSOL SubSampling ...")
sun_angle_col_step = int(
product_info.HeaderHandler.get_string_value_of(
"SunAngleColStep"))
sun_angle_row_step = int(
product_info.HeaderHandler.get_string_value_of(
"SunAngleRowStep"))
# ATTENTION : * -1 for compatibility negative spacing
LOGGER.debug(
"Angle Resolution Spacing computed in 5000 resolution: " +
str(sun_angle_col_step) + " , " + str(sun_angle_row_step))
l_zenithSolarAngles = product_info.HeaderHandler.get_sun_zenithal_angles(
)
l_azimuthSolarAngles = product_info.HeaderHandler.get_sun_azimuthal_angles(
)
LOGGER.debug("ZenithSolarAngles nb values: " +
str(len(l_zenithSolarAngles)))
LOGGER.debug("AzimuthSolarAngles nb values: " +
str(len(l_azimuthSolarAngles)))
l_solarAngleFile = app_handler.get_directory_manager(
).get_temporary_file("sun_angles_") + ".xml"
LOGGER.debug("Angles output_filename : %s", l_solarAngleFile)
writer = MajaInternalXmlInputAngles(l_zenithSolarAngles,
l_azimuthSolarAngles,
sun_angle_col_step,
sun_angle_row_step,
l_solarAngleFile)
writer.write()
# =======> GENERATE SOLAR ANGLE GRIDS
self.get_solar_grids(self._dem.ALC, l_solarAngleFile, l_SOLH1,
working_dir)
LOGGER.debug("Start IPSOL SubSampling done.")
# IPVIE Sub image pipeline connection
LOGGER.debug("Start IPVIE SubSampling ...")
vie_angle_col_step = int(
product_info.HeaderHandler.get_string_value_of(
"SunAngleColStep"))
vie_angle_row_step = int(
product_info.HeaderHandler.get_string_value_of(
"SunAngleRowStep"))
LOGGER.debug("For each band ...")
for l_band in l_ListOfTOABandCode:
l1BandIdx = l_BandsDefinitions.get_band_id_in_l1(l_band)
# Get the list of detectors (index)
l_ListOfZone = product_info.HeaderHandler.get_list_of_zones(
l_band)
# Get the list of viewing angles in the header file of the tile
l_zenithVieAngles = product_info.HeaderHandler.get_viewing_zenithal_angles(
l_band)
l_azimuthVieAngles = product_info.HeaderHandler.get_viewing_azimuthal_angles(
l_band)
if len(l_zenithVieAngles) != len(l_azimuthVieAngles):
raise MajaExceptionPluginSentinel2Muscate(
"The number of detector for viewing zenithal angles and viewing azimuthal angles is different or null !"
)
# =======> GENERATE VIEWING ANGLE GRIDS
self.GetViewingGrids(l_band, l_NbBand, l_VIEHRef,
l_SatPixFileNames[l1BandIdx],
l_ZoneMaskFileNames[l1BandIdx],
l_NoDataMaskFileNames[l1BandIdx],
l_ListOfZone, vie_angle_col_step,
vie_angle_row_step, l_zenithVieAngles,
l_azimuthVieAngles, working_dir)
# end loop nbBand
LOGGER.debug("Start IPVIE SubSampling done.")
# To check mean angle values
# TODO
# IPEDGSub and L2EDG pipeline connection
# =======> GENERATE EDG IMAGES
self.generate_edg_images(working_dir)
# L2 TOA image pipeline connection
# =======> GENERATE L2 TOA IMAGES
self.generate_l2_toa_images(working_dir)
# IPSAT Sub and L2SAT image pipeline connection
# =======> GENERATE SAT IMAGES
self.generate_sat_images(working_dir)
# CLA image pipeline connection
# =======> GENERATE CLA IMAGES
self.generate_cla_images(l_RealL1NoData, working_dir)
# Fill the datas
self.dict_of_vals["IPEDGSubOutput"] = self._edgsubmask
self.dict_of_vals["SOL1Image"] = self._sol1image
l_DTMBandCode = xml_tools.as_string_list(
l2comm.get_value("DTMViewingDirectionBandCode"))[0]
l_DTMBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_DTMBandCode)
self.dict_of_vals["DTMVIEImage"] = self._vieimagelist[l_DTMBandIdx]
LOGGER.debug("l_DTMBandIdx : ")
LOGGER.debug(l_DTMBandIdx)
self.dict_of_vals["IPTOASubOutput"] = self._sub_toa
self.dict_of_vals["L2TOAImageList"] = self._l2toaimagelist
self.dict_of_vals["ViewingZenithMeanMap"] = self._meanZenithMap
self.dict_of_vals["ViewingAzimuthMeanMap"] = self._meanAzimuthMap
self.dict_of_vals["CLAImage"] = self._claimage
self.dict_of_vals["IPSATSubOutput"] = self._subsatimage
l_CLDBandCode = l2comm.get_value("CLDViewingDirectionBandCode")
l_CLDBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CLDBandCode)
LOGGER.debug("l_CLDBandIdx: ")
LOGGER.debug(l_CLDBandIdx)
self.dict_of_vals["ShadowVIEImage"] = self._vieimagelist[
l_CLDBandIdx]
l_CirrusBandCode = l2comm.get_value("CirrusBandCode")
l_CirrusBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CirrusBandCode)
LOGGER.debug("l_CirrusBandIdx: ")
LOGGER.debug(l_CirrusBandIdx)
self.dict_of_vals["L1TOACirrusImage"] = self._toa_scalar_list[
l_CirrusBandIdx]
self.dict_of_vals["AngleZoneMaskList"] = self._l2zoneimagelist
self.dict_of_vals["L2EDGOutputList"] = self._l2edgmasklist
self.dict_of_vals["L2SATImageList"] = self._l2satmasklist
self.dict_of_vals["L2PIXImageList"] = self._l2piximagelist
self.dict_of_vals["L2DFPImageList"] = self._l2dfpimagelist
def run(self, dict_of_input, dict_of_output):
LOGGER.info("AthmosphericAbsorption start")
atm_working = dict_of_input.get("AppHandler").get_directory_manager().get_temporary_directory("AtmoProc_",
do_always_remove=True)
l_writeL2 = dict_of_input.get("Params").get("WriteL2ProductToL2Resolution")
bands_definition = dict_of_input.get("Plugin").BandsDefinitions
# Get some datas
pressure_image_sub = os.path.join(atm_working, "atmo_pressure_sub.tif")
param_pressure = {"dtm": dict_of_input.get("DEM").ALC,
"pressure": pressure_image_sub}
pressure_app_sub = OtbAppHandler("PressureFilter", param_pressure,
write_output=True)
self._coarse_pipeline.add_otb_app(pressure_app_sub)
viewing_zenith = dict_of_input.get("L1Info").ListOfViewingZenithAnglesPerBandAtL2CoarseResolution
water_amount_image_sub = os.path.join(atm_working, "atmo_wateramount_sub.tif")
if dict_of_input.get("Plugin").WaterVapourDetermination and not as_bool(
dict_of_input.get("L2COMM").get_value("GIP_L2COMM_UseDefaultConstantWaterAmount")):
watervaporreferencebandid = bands_definition.get_band_id_in_l2_coarse(
dict_of_input.get("L2COMM").get_value("WaterVaporReferenceBandCode"))
watervaporbandid = bands_definition.get_band_id_in_l2_coarse(
dict_of_input.get("L2COMM").get_value("WaterVaporBandCode"))
viewing_zenith_vapor_band = float(viewing_zenith[watervaporbandid])
param_watervapour = {"toa": dict_of_input.get("L1Reader").get_value("IPTOASubOutput"),
"watervaporreferencebandid": watervaporreferencebandid,
"watervaporbandid": watervaporbandid,
"vapnodatavalue": float(dict_of_input.get("L2COMM").get_value("VAPNodataValue")),
"watervapormaxthreshold": float(
dict_of_input.get("L2COMM").get_value("WaterVaporMaxThreshold")),
"solarzenith": float(dict_of_input.get("L1Info").SolarAngle["sun_zenith_angle"]),
"viewingzenith": viewing_zenith_vapor_band,
"wateramount": water_amount_image_sub,
"gipwatv": dict_of_input.get("L2WATV").new_gipp_filename}
water_vapour_app_sub = OtbAppHandler("WaterAmountGeneratorFilter", param_watervapour,
write_output=False)
self._coarse_pipeline.add_otb_app(water_vapour_app_sub)
dict_of_output["VAP_Sub"] = water_vapour_app_sub.getoutput()["wateramount"]
toac_image_sub = os.path.join(atm_working, "atmo_toac_sub.tif")
param_toa_correction = {"toa": dict_of_input.get("L1Reader").get_value("IPTOASubOutput"),
"pressure": pressure_app_sub.getoutput()["pressure"],
"smac": dict_of_input.get("L2SMAC").new_gipp_filename,
"wateramountdefault": float(
dict_of_input.get("L2COMM").get_value("WaterAmountDefaultValue")),
"nodata": dict_of_input.get("Params").get("RealL2NoData"),
"ozoneamount": dict_of_input.get("Params").get("OzoneAmount"),
"thetas": float(dict_of_input.get("L1Info").SolarAngle["sun_zenith_angle"]),
"thetav": viewing_zenith,
"bandlist": bands_definition.get_list_of_band_id_in_l2_coarse(),
"toac": toac_image_sub}
if (dict_of_input.get("Plugin").WaterVapourDetermination and
dict_of_input.get("L2COMM").get_value("GIP_L2COMM_UseDefaultConstantWaterAmount")):
param_toa_correction["wateramount"] = dict_of_output["VAP_Sub"]
toa_correction_app_sub = OtbAppHandler("TOACorrection", param_toa_correction, write_output=l_writeL2)
if not l_writeL2:
self._coarse_pipeline.add_otb_app(toa_correction_app_sub)
dict_of_output["AtmoAbsIPTOAC"] = toa_correction_app_sub.getoutput()["toac"]
if dict_of_input.get("Params").get("WriteL2ProductToL2Resolution"):
l_nbRes = len(bands_definition.ListOfL2Resolution)
for r in range(0, l_nbRes):
l_res = bands_definition.ListOfL2Resolution[r]
pressure_image = os.path.join(atm_working, "atmo_pressure_" + l_res + ".tif")
param_pressure["dtm"] = dict_of_input.get("DEM").ALTList[r]
param_pressure["pressure"] = pressure_image
pressure_app = OtbAppHandler("PressureFilter", param_pressure,write_output=False)
self._l2_pipeline.add_otb_app(pressure_app)
water_image = os.path.join(atm_working, "atmo_wateramount_" + l_res + ".tif")
if (dict_of_input.get("Plugin").WaterVapourDetermination and
dict_of_input.get("L2COMM").get_value("GIP_L2COMM_UseDefaultConstantWaterAmount")):
param_resamp = {"dtm": dict_of_input.get("DEM").ALTList[r],
"im": dict_of_output["VAP_Sub"],
"interp": "linear",
"padradius": 4.0,
"out": water_image}
water_app = OtbAppHandler("Resampling", param_resamp, write_output=False)
self._l2_pipeline.add_otb_app(water_app)
param_toa_correction["wateramount"] = water_app.getoutput().get("out")
toac_image = os.path.join(atm_working, "atmo_toa_" + l_res + ".tif")
param_toa_correction["toa"] = dict_of_input.get("L1Reader").get_value("L2TOAImageList")[r]
param_toa_correction["pressure"] = pressure_app.getoutput().get("pressure")
band_list = bands_definition.get_list_of_l2_band_id(l_res)
LOGGER.debug("Athmo band_list")
LOGGER.debug(band_list)
viewing_zenith_l2 = []
band_list_l2 = []
for i in band_list:
viewing_zenith_l2.append(viewing_zenith[i])
band_list_l2.append(str(i))
param_toa_correction["bandlist"] = band_list_l2
param_toa_correction["thetav"] = viewing_zenith_l2
param_toa_correction["toac"] = toac_image
toa_app = OtbAppHandler("TOACorrection", param_toa_correction,write_output=False)
self._l2_pipeline.add_otb_app(toa_app)
dict_of_output["AtmoAbsIPTOA_" + l_res] = toa_app.getoutput().get("toac")
dict_of_output["L2TOA_" + l_res] = toa_app.getoutput().get("toac")
def read(self, product_info, app_handler, l2comm, dem, pReadL1Mode):
"""product_info,plugin, l2comm,mode
:param product_info: L1ImageInformationsBase
:param pReadL1Mode: ReadL1ModeType
:return:
"""
LOGGER.info("Start Muscate L1 ImageFileReader ...")
product_filename = product_info.HeaderFilename
LOGGER.info("Start Muscate L1 ImageFileReader with filename : " +
product_filename)
working_dir = app_handler.get_directory_manager(
).get_temporary_directory("L1Read_", do_always_remove=True)
self._plugin.initialize(app_handler)
self._GIPPL2COMMHandler = l2comm
LOGGER.info("Start Muscate L1 ImageFileReader ...")
self._ReadL1Mode = pReadL1Mode
self._dem = dem
self._header_handler = product_info.HeaderHandler
# --------------------------------------
# Check the extension of th efile. For Muscate, must be .XML (in upper case)
IsValidSatellite = (self._header_handler is not None)
if not IsValidSatellite:
raise MajaExceptionPluginMuscate(
"The file <{}> is not a valid Muscate L1 product.".format(
product_filename))
# Get satellite name
self.m_Satellite = product_info.Satellite
# --------------------------------------
# Load the header tile file in the xml tile handler to read tile information
xmlTileFilename = product_info.xmlTileFilename
l_BandsDefinitions = self._plugin.BandsDefinitions # BandsDefinitions
# TOA & masks Reader connection
l_ListOfTOAImageFileNamesInHeader = self._header_handler.get_list_of_toa_image_filenames(
)
l_ListOfTOAImageFileNames = []
l_ListOfTOABandCode = l_BandsDefinitions.get_list_of_band_code_in_l2_coarse_sorted_by_index(
) # ListOfStrings
for band in l_ListOfTOABandCode:
LOGGER.debug(band)
l_ListOfTOAImageFileNames.append(l_ListOfTOAImageFileNamesInHeader[
self._header_handler.get_index_of_band_code(band)])
l_ListOfL1Resolution = l_BandsDefinitions.ListOfL1Resolution # ListOfStrings
l_ListOfL2Resolution = l_BandsDefinitions.ListOfL2Resolution # ListOfStrings
l_L1NoData = product_info.L1NoData
l_ReflectanceQuantificationValue = product_info.ReflectanceQuantification
l_RealL1NoData = l_L1NoData * l_ReflectanceQuantificationValue # RealNoDataType
# =======> GENERATE TOA
# Get calibration coeffs if activated
l_reflectanceMultiplicationValues = [] # ListOfDoubles
if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")):
l_factors = xml_tools.as_float_list(
l2comm.get_value("CalAdjustFactor"))
if len(l_factors) != len(l_ListOfTOABandCode):
raise MajaDataException(
"Not the same number of Calibration coeffs than L1 bands ( {}, {} )"
.format(len(l_factors), len(l_ListOfTOABandCode)))
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue * l_factors[i])
else:
for i in range(len(l_ListOfTOABandCode)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue)
l_ProjectionRef = self._dem.ProjRef
self.generate_toa(l_ListOfTOAImageFileNames,
l_reflectanceMultiplicationValues,
working_dir) # string
if pReadL1Mode == ReadL1Mode.READ_L1_MODE_FOR_ALGORITHMS:
# --------------------------------------
# Get information of areas (footprint) of the product (Origin, Spacing and Size for L2 and L2Coarse resolution)
l_L2Dems = dem.ALTList
l_CoarseDem = dem.ALC
# =======> GENERATE TOA SUB IMAGES AT L2 COARSE RESOLUTION
LOGGER.debug("Start SubSampling ...")
self.generate_toa_sub_images(working_dir)
LOGGER.debug("Start SubSampling done.")
# the gml mask per L2 resolution per band
self.generate_mask_rasters(l_ListOfTOABandCode, working_dir)
# IPEDGSub and L2EDG pipeline connection
# L2 TOA image pipeline connection
# =======> GENERATE L2 TOA IMAGES
self.generate_l2_toa_images(working_dir)
# =======> GENERATE L1 TOA IMAGES
self.generate_l1_toa_images(working_dir)
# =======> GENERATE EDG IMAGES
self.generate_edg_images(working_dir)
# IPSAT Sub and L2SAT image pipeline connection
# =======> GENERATE SAT IMAGES
self.generate_sat_images(working_dir)
# CLA image pipeline connection
# *********************************************************************************************************
self.generate_cla_image(l_RealL1NoData, working_dir)
# SOL1 image pipeline connection
# *********************************************************************************************************
sol_h1 = self._plugin.ConfigUserCamera.get_Algorithms(
).get_GRID_Reference_Altitudes().get_SOLH1()
LOGGER.debug("sol_H1 : ")
LOGGER.debug(sol_h1)
self.generate_sol1_image(sol_h1, working_dir)
# SOL2 image pipeline connection
# *********************************************************************************************************
if self._plugin.GRIDReferenceAltitudesSOL2GridAvailable:
sol_h2 = self._plugin.ConfigUserCamera.get_Algorithms(
).get_GRID_Reference_Altitudes().get_SOLH2()
self.generate_sol2_image(sol_h2, working_dir)
# VIE image pipeline connection
# *********************************************************************************************************
vie_href = self._plugin.ConfigUserCamera.get_Algorithms(
).get_GRID_Reference_Altitudes().get_VIEHRef()
self.generate_vie_image(vie_href, working_dir)
# Fill the datas
self.dict_of_vals["IPEDGSubOutput"] = self._edgsubmask
self.dict_of_vals["SOL1Image"] = self._sol1image
self.dict_of_vals["SOL2Image"] = self._sol2image
if len(self._vieimagelist) > 2:
l_DTMBandCode = xml_tools.as_string_list(
l2comm.get_value("DTMViewingDirectionBandCode"))[0]
l_DTMBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_DTMBandCode)
LOGGER.info("DTMBandCode= " + l_DTMBandCode)
self.dict_of_vals["DTMVIEImage"] = self._vieimagelist[
l_DTMBandIdx]
else:
self.dict_of_vals["DTMVIEImage"] = self._vieimagelist[0]
self.dict_of_vals["IPTOASubOutput"] = self._sub_toa
self.dict_of_vals["L2TOAImageList"] = self._l2toaimagelist
self.dict_of_vals["ViewingZenithMeanMap"] = self._meanZenithMap
self.dict_of_vals["ViewingAzimuthMeanMap"] = self._meanAzimuthMap
self.dict_of_vals["CLAImage"] = self._claimage
self.dict_of_vals["IPSATSubOutput"] = self._subsatimage
if len(self._vieimagelist) > 2:
l_CLDBandCode = l2comm.get_value("CLDViewingDirectionBandCode")
l_CLDBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CLDBandCode)
self.dict_of_vals["ShadowVIEImage"] = self._vieimagelist[
l_CLDBandIdx]
elif len(self._vieimagelist) > 1:
self.dict_of_vals["ShadowVIEImage"] = self._vieimagelist[1]
else:
self.dict_of_vals["ShadowVIEImage"] = self._vieimagelist[0]
if self._plugin.CirrusMasking:
l_CirrusBandCode = l2comm.get_value("CirrusBandCode")
l_CirrusBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CirrusBandCode)
self.dict_of_vals["L1TOACirrusImage"] = self._toa_scalar_list[
l_CirrusBandIdx]
self.dict_of_vals["L2EDGOutputList"] = self._l2edgmasklist
self.dict_of_vals["L2SATImageList"] = self._l2satmasklist
self.dict_of_vals["L2PIXImageList"] = self._l2dfpimagelist
def read(self, product_info, app_handler, l2comm, dem, pReadL1Mode):
"""product_info,plugin, l2comm,mode
:param product_info: L1ImageInformationsBase
:param pReadL1Mode: ReadL1ModeType
:return:
"""
LOGGER.debug("Start Venus L1 ImageFileReader ...")
product_filename = product_info.HeaderFilename
LOGGER.debug("Start Venus L1 ImageFileReader with the filename: " +
product_filename)
self._plugin.initialize(app_handler)
self.headerHandler = product_info.HeaderHandler
self._dem = dem
# working_dir = get_working_directory("L1Read_", app_handler.get_working_directory())
working_dir = app_handler.get_directory_manager(
).get_temporary_directory("L1Read_", do_always_remove=True)
self.ReadL1Mode = pReadL1Mode
self._GIPPL2COMMHandler = l2comm
l_BandsDefinitions = self._plugin.BandsDefinitions
# --------------------------------------
# Initialize the Image filename provider
l_FilenameProvider = VenusL1ImageFilenames()
#product_info.FilenamesProvider
IsValidSatellite = (l_FilenameProvider.initialize(product_filename)
is not False)
if not IsValidSatellite:
raise MajaPluginVenusException(
"The file <{}> is not a valid Venus L1 product.".format(
product_filename))
# *********************************************************************************************************
# Register the Header o the Input image file
# *********************************************************************************************************
LOGGER.debug("Load the Venus L1 Header file : '" + product_filename +
"'")
l_L1XMLHandler = HeaderImageEarthExplorerXMLFileHandler(
product_filename)
# *********************************************************************************************************
# TOA Reader connection
# *********************************************************************************************************
l_L1NoData = l_L1XMLHandler.get_no_data_value_as_double()
l_ReflectanceQuantificationValue = l_L1XMLHandler.get_reflectance_quantification_value(
)
l_reflectanceMultiplicationValues = []
if xml_tools.as_bool(l2comm.get_value("CalAdjustOption")):
l_factor = xml_tools.as_float_list(
l2comm.get_value("CalAdjustFactor"))
if len(l_factor) != (VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1):
raise MajaPluginVenusException(
"Not the same number of Calibration coeffs than L1 bands")
for i in range(0, len(l_factor)):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue * l_factor[i])
else:
for i in range(VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1):
l_reflectanceMultiplicationValues.append(
l_ReflectanceQuantificationValue)
l_RealL1NoData = l_L1NoData * l_ReflectanceQuantificationValue
# *********************************************************************************************************
# L1 TOA image pipeline connection
# *********************************************************************************************************
if not l_FilenameProvider.m_TOAImageFileName:
raise MajaPluginVenusException(
"VenusL1ImageFileReader : The TOA image does not exist !")
tmp_l1toa_roi = os.path.join(working_dir, "l1toa_roi.tif")
app_l1_toa_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName, [
channel
for channel in range(VenusL1ImageFileReader.TOALastChannel -
VenusL1ImageFileReader.TOAFirstChannel + 1)
],
tmp_l1toa_roi,
write_output=False)
self._l1toa_pipeline.add_otb_app(app_l1_toa_roi)
tmp_sat_roi = os.path.join(working_dir, "sat_roi.tif")
app_sat_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName,
[VenusL1ImageFileReader.SATChannel - 1],
tmp_sat_roi,
write_output=False)
self._sat_pipeline.add_otb_app(app_sat_roi)
#Multiply scalar by quantif
tmp_l1toa_mbs = os.path.join(working_dir, "l1toa.tif")
app_l1toa_mbs = multiply_by_scalar(
app_l1_toa_roi.getoutput().get("out"),
l_ReflectanceQuantificationValue,
output_image=tmp_l1toa_mbs,
write_output=False)
self._l1toa_pipeline.add_otb_app(app_l1toa_mbs)
# update all extract ROI in once
write_images([
app_l1toa_mbs.getoutput().get("out"),
app_sat_roi.getoutput().get("out")
], [tmp_l1toa_mbs, tmp_sat_roi])
self._toascalar = tmp_l1toa_mbs
# *********************************************************************************************************
# L1 PIX image pipeline connection
# *********************************************************************************************************
tmp_l1pix_roi = os.path.join(working_dir, "l1pix.tif")
app_l1_pix_roi = extract_roi(l_FilenameProvider.m_TOAImageFileName,
[VenusL1ImageFileReader.PIXChannel - 1],
tmp_l1pix_roi + ":uint16",
write_output=False)
self._l1pix_pipeline.add_otb_app(app_l1_pix_roi)
self._l1pix = app_l1_pix_roi.getoutput().get("out")
# *********************************************************************************************************
# START READ L1 for ALGORITHMS
# *********************************************************************************************************
if pReadL1Mode == ReadL1Mode.READ_L1_MODE_FOR_ALGORITHMS:
# *********************************************************************************************************
# L2 PIX image pipeline connection
# *********************************************************************************************************
# LAIG-FA-MAC-131720-CS : New for 4.2
# Before resample, binarytovector -> resample -> vectortobinary
tmp_l2pix_bin2vec = os.path.join(working_dir, "l2pix_bin2vec.tif")
param_l2pix_bin2vec = {
"im": app_l1_pix_roi.getoutput().get("out"),
"out": tmp_l2pix_bin2vec + ":uint8",
"nbcomp": VenusL1ImageFileReader.PIXNumberOfComponentsPerPixel
}
app_l2pix_bin2vec = OtbAppHandler("BinaryToVector",
param_l2pix_bin2vec,
write_output=False)
self._l2pix_pipeline.add_otb_app(app_l2pix_bin2vec)
tmp_l2pix_resample = os.path.join(working_dir,
"l2pix_resample.tif")
app_l2pix_resample = resample(
app_l2pix_bin2vec.getoutput().get("out"),
self._dem.ALTList[0],
tmp_l2pix_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
threshold=0.0,
write_output=False)
self._l2pix_pipeline.add_otb_app(app_l2pix_resample)
#L2 PIX is concatenate
tmp_l2pix_binconcat = os.path.join(working_dir, "l2pix.tif")
param_l2pix_binconcat = {
"im": app_l2pix_resample.getoutput().get("out"),
"out": tmp_l2pix_binconcat + ":uint16"
}
app_l2pix_binconcat = OtbAppHandler("BinaryConcatenate",
param_l2pix_binconcat,
write_output=False)
self._l2pix = app_l2pix_binconcat.getoutput().get("out")
self._l2pix_pipeline.add_otb_app(app_l2pix_binconcat)
# *********************************************************************************************************
# L2 EDG image pipeline connection
# *********************************************************************************************************
tmp_edg_thresholder = os.path.join(working_dir,
"edg_thresholder1.tif")
param_edg_thresholder1 = {
"im": self._toascalar,
"thresholdvalue": l_RealL1NoData,
"equalvalue": 255,
"outsidevalue": 0,
"out": tmp_edg_thresholder + ":uint8"
}
app_edg_thresholder1 = OtbAppHandler("OneBandEqualThreshold",
param_edg_thresholder1,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_thresholder1)
tmp_edg_resample = os.path.join(working_dir, "edg_resample.tif")
app_edg_resample = resample(
app_edg_thresholder1.getoutput().get("out"),
self._dem.ALTList[0],
tmp_edg_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_resample)
# Threshold the output
out_sub_edg = os.path.join(working_dir, "edg_thresholder2.tif")
param_edg_thresholder2 = {
"im": app_edg_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 1,
"outsidevalue": 0,
"out": out_sub_edg + ":uint8"
}
app_edg_thresholder2 = OtbAppHandler("OneBandEqualThreshold",
param_edg_thresholder2,
write_output=True)
self._edg_pipeline.add_otb_app(app_edg_thresholder2)
# *********************************************************************************************************
# IPEDGSub image pipeline connection
# *********************************************************************************************************
tmp_edgsub_resample = os.path.join(working_dir,
"edgsub_resample.tif")
app_edgsub_resample = resample(
app_edg_thresholder1.getoutput().get("out"),
self._dem.ALC,
tmp_edgsub_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=12.0,
write_output=True)
self._edg_pipeline.add_otb_app(app_edgsub_resample)
# Threshold the output
out_sub_edgsub = os.path.join(working_dir, "edgsub.tif")
param_edgsub_thresholder2 = {
"im": app_edgsub_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 0,
"outsidevalue": 1,
"out": out_sub_edgsub + ":uint8"
}
app_edgsub_thresholder2 = OtbAppHandler("OneBandEqualThreshold",
param_edgsub_thresholder2,
write_output=True)
self._edgsub = app_edgsub_thresholder2.getoutput().get("out")
self._edg_pipeline.add_otb_app(app_edgsub_thresholder2)
# *********************************************************************************************************
# L2 TOA image pipeline connection
# *********************************************************************************************************
tmp_l2toa_resample = os.path.join(working_dir,
"l2toa_resample.tif")
app_l2toa_resample = resample(self._toascalar,
self._dem.ALTList[0],
tmp_l2toa_resample,
OtbResampleType.BCO,
padradius=4.0,
write_output=False)
self._l2toa_pipeline.add_otb_app(app_l2toa_resample)
l2toa_list = []
l_toathresholdminvalue = 0
l_toathresholvalue = -10
#Apply EDG mask on l2toa resampled
tmp_l2toa = os.path.join(working_dir, "l2toa.tif")
app_l2toa = apply_mask(app_l2toa_resample.getoutput().get("out"),
app_edg_thresholder2.getoutput().get("out"),
l_toathresholvalue,
tmp_l2toa,
write_output=False)
self._l2toa = app_l2toa.getoutput().get("out")
self._l2toa_pipeline.add_otb_app(app_l2toa)
# *********************************************************************************************************
# TOA Sub image pipeline connection
# *********************************************************************************************************
tmp_toasub_resample = os.path.join(working_dir,
"toasub_resample.tif")
app_toasub_resample = resample(self._toascalar,
self._dem.ALC,
tmp_toasub_resample,
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
write_output=True)
self._l2toa_pipeline.add_otb_app(app_toasub_resample)
# Threshold the output
out_edgsub_threshold = os.path.join(working_dir,
"edgsubthreshold.tif")
param_edgsub_threshold = {
"im": app_edgsub_resample.getoutput().get("out"),
"thresholdvalue": 0,
"equalvalue": 1,
"outsidevalue": 0,
"out": out_edgsub_threshold + ":uint8"
}
app_edgsub_threshold = OtbAppHandler("OneBandEqualThreshold",
param_edgsub_threshold,
write_output=True)
self._edg_pipeline.add_otb_app(app_edgsub_threshold)
tmp_l2subtoa = os.path.join(working_dir, "toasub.tif")
app_l2subtoa = apply_mask(
app_toasub_resample.getoutput().get("out"),
app_edgsub_threshold.getoutput().get("out"),
l_toathresholvalue,
tmp_l2subtoa,
write_output=True)
self._toasub = app_l2subtoa.getoutput().get("out")
self._l2toa_pipeline.add_otb_app(app_l2subtoa)
# *********************************************************************************************************
# L2EDG - Actualization of the L2 edge mask
# *********************************************************************************************************
#tmp_l2edg_threshold = os.path.join(working_dir, "l2edg_threshold.tif")
#app_l2edg_threshold = binary_threshold(self._edgsub,
# lower_threshold=0,
# inside_value=1000,
# outside_value=0,
# output_image=tmp_l2edg_threshold + ":uint8",
# write_output=True)
#self._l2edg_pipeline.add_otb_app(app_l2edg_threshold)
tmp_l2edg_resample = os.path.join(working_dir, "l2edg.tif")
app_l2edg_resample = resample(self._edgsub,
self._dem.ALTList[0],
tmp_l2edg_resample + ":uint8",
OtbResampleType.LINEAR,
padradius=4.0,
threshold=0.001,
write_output=True)
self._l2edg = app_l2edg_resample.getoutput().get("out")
self._l2edg_pipeline.add_otb_app(app_l2edg_resample)
# *********************************************************************************************************
# SAT image pipeline connection
# *********************************************************************************************************
tmp_sat_bin2vec = os.path.join(working_dir, "sat_bin2vec.tif")
param_sat_bin2vec = {
"im": tmp_sat_roi,
"out": tmp_sat_bin2vec + ":uint8",
"nbcomp": VenusL1ImageFileReader.SATNumberOfComponentsPerPixel
}
app_sat_bin2vec = OtbAppHandler("BinaryToVector",
param_sat_bin2vec,
write_output=False)
self._sat_pipeline.add_otb_app(app_sat_bin2vec)
l_l2sat_thresholdvalue = l2comm.get_value_f("SaturationThreshold")
tmp_sat_resample = os.path.join(working_dir, "l2sat.tif")
app_sat_resample = resample(app_sat_bin2vec.getoutput().get("out"),
self._dem.ALTList[0],
tmp_sat_resample + ":uint8",
OtbResampleType.BCO,
padradius=4.0,
threshold=l_l2sat_thresholdvalue,
write_output=False)
self._l2sat = app_sat_resample.getoutput().get("out")
self._sat_pipeline.add_otb_app(app_sat_resample)
# *********************************************************************************************************
# IPSAT Sub image pipeline connection
# *********************************************************************************************************
l_sat_subthresholdvalue = l2comm.get_value_f(
"SaturationThresholdSub")
tmp_satsub_resample = os.path.join(working_dir, "satsub.tif")
app_satsub_resample = resample(
app_sat_bin2vec.getoutput().get("out"),
self._dem.ALC,
tmp_satsub_resample + ":uint8",
OtbResampleType.LINEAR_WITH_RADIUS,
padradius=4.0,
threshold=l_sat_subthresholdvalue)
self._satsub = app_satsub_resample.getoutput().get("out")
self._sat_pipeline.add_otb_app(app_satsub_resample)
# *********************************************************************************************************
# CLA image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - CLA image filename: '" +
l_FilenameProvider.m_CLAImageFileName + "'")
if not l_FilenameProvider.m_CLAImageFileName:
raise MajaPluginVenusException(
"The CLA image does not exist !! ")
self._cla = l_FilenameProvider.m_CLAImageFileName
# *********************************************************************************************************
# SOL1 image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - SOL image filename: '" +
l_FilenameProvider.m_SOLImageFileName + "'")
if not l_FilenameProvider.m_SOLImageFileName:
raise MajaPluginVenusException(
"The SOL image does not exist !! ")
mtdat = GdalDatasetInfo(l_FilenameProvider.m_TOAImageFileName)
toaarea = Area()
toaarea.size = mtdat.size
toaarea.origin = mtdat.origin
toaarea.spacing = mtdat.pixel_size
l_SOLHeaderHandler = HeaderImageEarthExplorerXMLFileHandler(
l_FilenameProvider.m_SOLHeaderFileName)
l_L1SOLSubsamplingFactor = l_SOLHeaderHandler.get_sampling_factor()
LOGGER.debug(l_L1SOLSubsamplingFactor)
# SOL1
tmp_sol1_b1 = os.path.join(working_dir, "sol1_B1.tif")
app_sol1_b1 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL1ChannelB1,
toaarea.spacing[0],
tmp_sol1_b1,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol1_b1)
tmp_sol1_b2 = os.path.join(working_dir, "sol1_B2.tif")
app_sol1_b2 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL1ChannelB2,
(-1) * toaarea.spacing[1],
tmp_sol1_b2,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol1_b2)
tmp_sol1_concat = os.path.join(working_dir, "sol1_concat.tif")
param_sol1_concat = {
"il": [
app_sol1_b1.getoutput().get("out"),
app_sol1_b2.getoutput().get("out")
],
"out":
tmp_sol1_concat
}
app_sol1_concat = OtbAppHandler("ConcatenateDoubleImages",
param_sol1_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_sol1_concat.getoutput().get("out"),
l_L1SOLSubsamplingFactor)
self._sol_pipeline.add_otb_app(app_sol1_concat)
tmp_sol1_resample = os.path.join(working_dir, "sol1.tif")
app_sol1_resample = resample(
app_sol1_concat.getoutput().get("out"),
self._dem.ALC,
tmp_sol1_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._sol1 = app_sol1_resample.getoutput().get("out")
self._sol_pipeline.add_otb_app(app_sol1_resample)
# SOL2
tmp_sol2_b1 = os.path.join(working_dir, "sol2_B1.tif")
app_sol2_b1 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL2ChannelB1,
toaarea.spacing[0],
tmp_sol2_b1,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol2_b1)
tmp_sol2_b2 = os.path.join(working_dir, "sol2_B2.tif")
app_sol2_b2 = multiply_by_scalar(
l_FilenameProvider.m_SOLImageFileName +
VenusL1ImageFileReader.SOL2ChannelB2,
(-1) * toaarea.spacing[1],
tmp_sol2_b2,
write_output=False)
self._sol_pipeline.add_otb_app(app_sol2_b2)
tmp_sol2_concat = os.path.join(working_dir, "sol2_concat.tif")
param_sol2_concat = {
"il": [
app_sol2_b1.getoutput().get("out"),
app_sol2_b2.getoutput().get("out")
],
"out":
tmp_sol2_concat
}
app_sol2_concat = OtbAppHandler("ConcatenateDoubleImages",
param_sol2_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_sol2_concat.getoutput().get("out"),
l_L1SOLSubsamplingFactor)
self._sol_pipeline.add_otb_app(app_sol2_concat)
tmp_sol2_resample = os.path.join(working_dir, "sol2.tif")
app_sol2_resample = resample(
app_sol2_concat.getoutput().get("out"),
self._dem.ALC,
tmp_sol2_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._sol2 = app_sol2_resample.getoutput().get("out")
self._sol_pipeline.add_otb_app(app_sol2_resample)
# *********************************************************************************************************
# DTMVIE image pipeline connection
# *********************************************************************************************************
LOGGER.debug(
"VenusL1ImageFileReader::Initialize - VIE image filename: '" +
l_FilenameProvider.m_VIEImageFileName + "'")
l_VIEHeaderHandler = HeaderImageEarthExplorerXMLFileHandler(
l_FilenameProvider.m_VIEHeaderFileName)
l_L1VIESubsamplingFactor = l_VIEHeaderHandler.get_sampling_factor()
LOGGER.debug(l_L1VIESubsamplingFactor)
tmp_vieb5b1_mult = os.path.join(working_dir, "vie5b1_mult.tif")
app_vieb5b1_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB5ChannelB1,
toaarea.spacing[0],
tmp_vieb5b1_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb5b1_mult)
tmp_vieb5b2_mult = os.path.join(working_dir, "vie5b2_mult.tif")
app_vieb5b2_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB5ChannelB2,
(-1) * toaarea.spacing[1],
tmp_vieb5b2_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb5b2_mult)
tmp_vieb6b1_mult = os.path.join(working_dir, "vie6b1_mult.tif")
app_vieb6b1_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB6ChannelB1,
toaarea.spacing[0],
tmp_vieb6b1_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb6b1_mult)
tmp_vieb6b2_mult = os.path.join(working_dir, "vie6b2_mult.tif")
app_vieb6b2_mult = multiply_by_scalar(
l_FilenameProvider.m_VIEImageFileName +
VenusL1ImageFileReader.VIEB6ChannelB2,
(-1) * toaarea.spacing[1],
tmp_vieb6b2_mult,
write_output=False)
self._dtmvie_pipeline.add_otb_app(app_vieb6b2_mult)
tmp_dtmvie_concat = os.path.join(working_dir, "dtmvie_concat.tif")
param_dtmvie_concat = {
"il": [
app_vieb5b1_mult.getoutput().get("out"),
app_vieb5b2_mult.getoutput().get("out"),
app_vieb6b1_mult.getoutput().get("out"),
app_vieb6b2_mult.getoutput().get("out")
],
"out":
tmp_dtmvie_concat
}
app_dtmvie_concat = OtbAppHandler("ConcatenateDoubleImages",
param_dtmvie_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_dtmvie_concat.getoutput().get("out"),
l_L1VIESubsamplingFactor)
self._dtmvie_pipeline.add_otb_app(app_dtmvie_concat)
tmp_dtmvie_resample = os.path.join(working_dir, "dtmvie.tif")
app_dtmvie_resample = resample(
app_dtmvie_concat.getoutput().get("out"),
self._dem.ALC,
tmp_dtmvie_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._dtmvie = app_dtmvie_resample.getoutput().get("out")
self._dtmvie_pipeline.add_otb_app(app_dtmvie_resample)
# *********************************************************************************************************
# VIE image pipeline connection
# *********************************************************************************************************
tmp_shadowvie_concat = os.path.join(working_dir,
"shadowvie_concat.tif")
param_shadowvie_concat = {
"il": [
app_vieb5b1_mult.getoutput().get("out"),
app_vieb5b2_mult.getoutput().get("out")
],
"out":
tmp_shadowvie_concat
}
app_shadowvie_concat = OtbAppHandler("ConcatenateDoubleImages",
param_shadowvie_concat)
self._shadowvie_pipeline.add_otb_app(app_shadowvie_concat)
update_projection(l_FilenameProvider.m_TOAImageFileName,
app_shadowvie_concat.getoutput().get("out"),
l_L1VIESubsamplingFactor)
tmp_shadowvie_resample = os.path.join(working_dir, "shadowvie.tif")
app_shadowvie_resample = resample(
app_shadowvie_concat.getoutput().get("out"),
self._dem.ALC,
tmp_shadowvie_resample,
OtbResampleType.LINEAR,
padradius=4.0)
self._shadowvie = app_shadowvie_resample.getoutput().get("out")
self._shadowvie_pipeline.add_otb_app(app_shadowvie_resample)
# Fill the datas
self.dict_of_vals["IPEDGSubOutput"] = self._edgsub
self.dict_of_vals["SOL1Image"] = self._sol1
self.dict_of_vals["SOL2Image"] = self._sol2
self.dict_of_vals["DTMVIEImage"] = self._dtmvie
self.dict_of_vals["IPTOASubOutput"] = self._toasub
self.dict_of_vals["L2TOAImageList"] = [self._l2toa]
self.dict_of_vals["ViewingZenithMeanMap"] = self._meanZenithMap
self.dict_of_vals["ViewingAzimuthMeanMap"] = self._meanAzimuthMap
self.dict_of_vals["CLAImage"] = self._cla
self.dict_of_vals["IPSATSubOutput"] = self._satsub
self.dict_of_vals["ShadowVIEImage"] = self._shadowvie
if self._plugin.CirrusMasking:
l_CirrusBandCode = l2comm.get_value("CirrusBandCode")
l_CirrusBandIdx = self._plugin.BandsDefinitions.get_band_id_in_l2_coarse(
l_CirrusBandCode)
tmp = os.path.join(working_dir, "l1toacirrus.tif")
app = extract_roi(self._toascalar, [l_CirrusBandIdx - 1], tmp)
self.dict_of_vals["L1TOACirrusImage"] = app.getoutput().get(
"out")
self.dict_of_vals["L2EDGOutputList"] = [self._l2edg]
self.dict_of_vals["L2SATImageList"] = [self._l2sat]
self.dict_of_vals["L2PIXImageList"] = [self._l2pix]
self.dict_of_vals["L1PIXImageList"] = [self._l1pix]
self.dict_of_vals["L1TOAImageList"] = [self._toascalar]
def get_value_b(self, key, check=False):
return xml_tools.as_bool(self.get_value(key, check))
