def pre(self, otb_app, parameters): """ :param parameters: :param otb_app: :return: """ # The following line creates an instance of the BandMath application self.otb_app = otbApplication.Registry_CreateApplicationWithoutLogger( otb_app) if self.otb_app is None: raise MajaDriverException("No app " + otb_app + " found") self.otb_app.Init() # The following lines set all the application parameters: LOGGER.debug("Parameters for %s : %s", otb_app, parameters) LOGGER.debug( "Parameters type %s", { key: (type(value), value.__class__.__name__) for key, value in parameters.items() }) # First set input image if "in" in parameters: parameters_im = {"in": parameters["in"]} self.otb_app.SetParameters(parameters_im) if not get_test_mode(): self.otb_app.UpdateParameters() # remove flag if set to false parameters_clean = {} for key, value in parameters.items(): if key in self.otb_app.GetParametersKeys(): if self.otb_app.GetParameterType(key) == otbApplication.ParameterType_OutputImage \ and len(value.split(":")) > 1: # split value into value and output type if value.split(":")[1] in OTB_APP_PIXELS_TYPE.keys(): parameters_clean[key] = (value.split(":")[0]) self.otb_app.SetParameterOutputImagePixelType( key, OTB_APP_PIXELS_TYPE.get(value.split(":")[1])) else: parameters_clean[key] = value else: parameters_clean[key] = value else: LOGGER.debug("%s removed because not in app list", key) continue self.otb_app.SetParameters(parameters_clean) # Update parameters for dynamics if not get_test_mode(): self.otb_app.UpdateParameters()
def post(self, write_output=True): LOGGER.debug("Write output %s", write_output) params_keys = self.otb_app.GetParametersKeys() for param in params_keys: # role == 1 -> output if self.otb_app.GetParameterRole(param) == 1 or self.otb_app.GetParameterType( param) == otbApplication.ParameterType_OutputImage: if get_test_mode(): if self.otb_app.GetParameterType(param) == otbApplication.ParameterType_Int: self.outputs[param] = 1 elif self.otb_app.GetParameterType(param) == otbApplication.ParameterType_Float: self.outputs[param] = 1.0 elif self.otb_app.GetParameterType(param) == otbApplication.ParameterType_String: self.outputs[param] = "false" else: self.outputs[param] = copy.deepcopy(self.otb_app.GetParameterValue(param)) else: if write_output: if not self.otb_app.GetParameterType(param) == otbApplication.ParameterType_Group: self.outputs[param] = copy.deepcopy(self.otb_app.GetParameterValue(param)) else: if self.otb_app.GetParameterType(param) == otbApplication.ParameterType_OutputImage: self.outputs[param] = self.otb_app.GetParameterOutputImage(param) else: if not self.otb_app.GetParameterType(param) == otbApplication.ParameterType_Group: self.outputs[param] = copy.deepcopy(self.otb_app.GetParameterValue(param)) if write_output: self.otb_app.FreeRessources() del self.otb_app self.otb_app = None
def copy_file_to_directory(sourcefilename, destinationdir, notestmode=False): destinationfilename = os.path.join(destinationdir, os.path.basename(sourcefilename)) if not get_test_mode() or notestmode: shutil.copyfile(sourcefilename, destinationfilename) else: with open(destinationfilename, 'a'): os.utime(destinationfilename, None) return destinationfilename
def extract_roi(input_file_path, channels, output_image, write_output=True): parameters = { "in": input_file_path, "cl": ["Channel" + str(idx + 1) for idx in channels], "out": output_image } if get_test_mode(): parameters.pop("cl") app = OtbAppHandler("ExtractChannels", parameters, write_output) return app
def otb_copy_file_to_directory(sourceFilename, destinationDir): destinationFilename = os.path.join(destinationDir, os.path.basename(sourceFilename)) if not get_test_mode(): if type(sourceFilename).__name__ == "SwigPyObject": write_images([sourceFilename], [destinationFilename]) else: shutil.copyfile(sourceFilename, destinationFilename) else: with open(destinationFilename, 'a'): os.utime(destinationFilename, None) return destinationFilename
def __init__(self, otb_app, parameters, write_output=True): self._c1 = MajaOtbCots() self._app_name = otb_app LOGGER.debug("Initializing : " + self._app_name) if "ram" not in list(parameters.keys()): curr_ram = int(memory_used_by_process_current(os.getpid())) avail_ram = OtbAppHandler.ram_to_use - curr_ram if avail_ram < OtbAppHandler.ram_to_use/OtbAppHandler.ram_limit_factor: parameters["ram"] = str(OtbAppHandler.ram_to_use / OtbAppHandler.ram_limit_factor) else: parameters["ram"] = str(avail_ram) LOGGER.debug(parameters) self._write_output = not is_croco_off() and (write_output or is_croco_on()) self._c1.pre(otb_app, parameters) if not get_test_mode(): self._run() self._post()
def otb_copy_image_to_file(source, dest, raise_exceptions=True): if not get_test_mode(): if type(source).__name__ == "SwigPyObject": write_images([source], [dest]) else: LOGGER.debug("source : " + source + " , dest : " + dest) try: if not os.path.exists(dest) or not os.path.samefile(source, dest): shutil.copyfile(source, dest) except IOError as err: if raise_exceptions: raise MajaIOError(err) else: LOGGER.warn("Copy failed !!!") else: with open(dest, 'a'): os.utime(dest, None)
def run_rasterize(self, inputfilename, xmin, ymin, xmax, ymax, size_x, size_y, projection, outputfilename, gdaladditionalcommandlineparameters): """ :param inputfilename: string :param xmin: int :param ymin: int :param xmax: int :param ymax: int :param size_x: int :param size_y: int :param projection: string :param outputfilename: string :param gdaladditionalcommandlineparameters: string :return: """ # Call the gdal_rasterize command system with the specific parameters self.command_line = ( """gdal_rasterize """ + gdaladditionalcommandlineparameters + """ -te """ + str(xmin) + """ """ + str(ymin) + """ """ + str(xmax) + """ """ + str(ymax) + """ -ts """ + str(size_x) + """ """ + str(size_y) + """ -a_srs '""" + projection + """ ' """ + inputfilename + """ """ + outputfilename) LOGGER.debug(self.command_line) if not get_test_mode(): self.run() return self.status
def copy_file(source, dest, notestmode=False): if not get_test_mode() or notestmode: shutil.copyfile(source, dest) else: with open(dest, 'a'): os.utime(dest, None)
def extract_cams_datas(self, corner_lat, corner_lon, p_imageproductaquisitiontimejd): self.valid = False if not self.searchvalidcamsfilenames(p_imageproductaquisitiontimejd): LOGGER.info("No CAM found for JD Date " + str(p_imageproductaquisitiontimejd)) return if p_imageproductaquisitiontimejd < self._cams_46r1_switch: try: self._models.remove("AMMONIUM") self._models.remove("NITRATE") LOGGER.debug("Removed 46r1 models.") except ValueError: LOGGER.warning("Cannot remove 46r1 models. CAMS models present: %s" % self._models) cams_app_param = {"models": self._models, "rhsampling": self._rhsampling, "limaod": self._limaod, "lat": corner_lat, "lon": corner_lon, "datejulian": p_imageproductaquisitiontimejd, "sumofaot": os.path.join(self._working_dir, "tmpaot.tiff") } # Create the xml instance of cams app configuration file xml_model_list = ModelListType() for model, mapex in list(self._extinction_map.items()): xml_model = ModelType() xml_extinction_coeff_list = Extinction_Coefs_ListType() count = 1 for ext in mapex["extinction_coeffs"]: xml_extinction_coeff = Extinction_CoefType() xml_extinction_coeff.set_Name(ext["Name"]) xml_extinction_coeff.set_Values(ext["Values"]) xml_extinction_coeff.set_Description(ext["Description"]) xml_extinction_coeff.set_n(count) count = count + 1 xml_extinction_coeff_list.add_Extinction_Coef(xml_extinction_coeff) xml_extinction_coeff_list.set_count(len(model)) xml_model.set_RhDep(bool(mapex["rh_dep"])) xml_model.set_Name(model) xml_model.set_Extinction_Coefs_List(xml_extinction_coeff_list) xml_model_list.add_Model(xml_model) xml_cams = CAMS() xml_cams.set_ModelList(xml_model_list) xml_cams.set_RhTab(self._rhtab) # build file output = io.StringIO() output.write('<?xml version="1.0" ?>\n') xml_cams.export(output, 0, name_='CAMS', namespacedef_='', pretty_print=True) xml_filename = os.path.join(self._working_dir, "cams_description.xml") with open(xml_filename, "w") as fh: fh.write(output.getvalue().replace(" ", " ")) LOGGER.info("Writed cams description to " + xml_filename) cams_app_param["camsdescription"] = xml_filename if self._beforefilefound: cams_app_param["before.dateutc"] = self._beforeFile["date_utc"] cams_app_param["before.aotfile"] = self._beforeFile["aot_file"] cams_app_param["before.mrfile"] = self._beforeFile["mr_file"] cams_app_param["before.rhfile"] = self._beforeFile["rh_file"] cams_app_param["before.modellevels"] = self._beforeFile["model_levels"] if "NbNonInterpolate" in self._beforeFile.keys(): cams_app_param["before.nbnointerpol"] = self._beforeFile["NbNonInterpolate"] if self._afterfilefound: cams_app_param["after.dateutc"] = self._afterFile["date_utc"] cams_app_param["after.aotfile"] = self._afterFile["aot_file"] cams_app_param["after.mrfile"] = self._afterFile["mr_file"] cams_app_param["after.rhfile"] = self._afterFile["rh_file"] cams_app_param["after.modellevels"] = self._afterFile["model_levels"] if "NbNonInterpolate" in self._afterFile.keys(): cams_app_param["after.nbnointerpol"] = self._afterFile["NbNonInterpolate"] self.__camsapp = OtbAppHandler("CAMSComputation", cams_app_param, write_output=True) l_app_proportions = self.__camsapp.getoutput().get("proportions") if get_test_mode(): for m in xml_model_list.get_Model(): self.proportions[m.get_Name()] = 1.0 / len(xml_model_list.get_Model()) else: for p in l_app_proportions.split(";"): if len(p) != 0: l_model = p.split("=")[0] l_value = p.split("=")[1] self.proportions[l_model] = l_value self.out_rh_sampling = self.__camsapp.getoutput().get("rh") self.valid = True self.out_sum_of_aot = self.__camsapp.getoutput().get("sumofaot")