ign-borea 0.1.5__py3-none-any.whl → 0.2.2__py3-none-any.whl

borea/datastruct/dtm.py

@@ -1,11 +1,11 @@
 """
 A module for manipulating a digital elevation model.
 """
-from pathlib import Path, PureWindowsPath
 import numpy as np
 from osgeo import gdal
 from scipy import ndimage
 from borea.transform_world_image.transform_dtm.world_image_dtm import WorldImageDtm
+from borea.utils.check.check_path import check_path
 from borea.utils.singleton.singleton import Singleton
 gdal.UseExceptions()
 
@@ -49,7 +49,7 @@ class Dtm(WorldImageDtm, metaclass=Singleton):
         if path_dtm:
             gdal.AllRegister()
             self.type_dtm = type_dtm
-            self.path_dtm = Path(PureWindowsPath(path_dtm))
+            self.path_dtm = check_path(path_dtm)
             self.img = gdal.Open(self.path_dtm.as_posix())
             self.rb = self.img.GetRasterBand(1)
             self.nodata = self.rb.GetNoDataValue()

borea/datastruct/shot.py

@@ -9,7 +9,7 @@ from borea.geodesy.local_euclidean_proj import LocalEuclideanProj
 from borea.utils.check.check_order_axe import check_order_axe
 
 
-# pylint: disable=too-many-instance-attributes too-many-arguments
+# pylint: disable=too-many-instance-attributes too-many-arguments too-many-positional-arguments
 class Shot:
     """
     Shot class definition.
@@ -153,9 +153,9 @@ class Shot:
             type_z (str): z type height or altitude.
         """
         if type_z == "height":
-            self.pos_shot[2] = ProjEngine().tranform_height(self.pos_shot)
+            self.pos_shot[2] = ProjEngine().tf.tranform_height(self.pos_shot)
         else:
-            self.pos_shot[2] = ProjEngine().tranform_altitude(self.pos_shot)
+            self.pos_shot[2] = ProjEngine().tf.tranform_altitude(self.pos_shot)
 
     def set_linear_alteration(self, linear_alteration: bool) -> None:
         """
@@ -185,6 +185,12 @@ class Shot:
             self.ori_shot = -(R.from_euler("x", np.pi) *
                               R.from_matrix(self.mat_rot)).as_euler(order_xyz, degrees=unitori)
 
+    def set_proj_pos(self) -> None:
+        """
+        Change the projection of the position shot with the epsg_output.
+        """
+        self.pos_shot = np.array(ProjEngine().tf.proj_to_proj_out(*self.pos_shot))
+
     def get_z_remove_scale_factor(self) -> float:
         """
         Return Z after removing the scale factor. The Z of the object is NOT modified.

borea/datastruct/workdata.py

@@ -33,8 +33,9 @@ class Workdata:
         self.type_z_data = None
         self.type_z_shot = None
         self.approxeucli = False
+        self.epsg_output = False
 
-    # pylint: disable-next=too-many-arguments
+    # pylint: disable-next=too-many-arguments too-many-positional-arguments
     def add_shot(self, name_shot: str, pos_shot: np.ndarray,
                  ori_shot: np.ndarray, name_cam: str,
                  unit_angle: str, linear_alteration: bool,
@@ -59,24 +60,30 @@ class Workdata:
                                      linear_alteration=linear_alteration,
                                      order_axe=order_axe)
 
-    def set_proj(self, epsg: int, path_geoid: list = None) -> None:
+    def set_proj(self, epsg: list, path_geoid: list = None, epsg_output: int = None) -> None:
         """
         Setup a projection system to the worksite.
 
         Args:
-            epsg (int): Code epsg of the porjection ex: 2154.
+            epsg (list): Code epsg of the projection ex: [2154].
             path_geoid (str): List of GeoTIFF which represents the geoid in grid form.
+            epsg_output (int): Code epsg of the output projection. If you want to change.
         """
         ProjEngine.clear()
-        try:  # Check if the epsg exist
-            crs = CRS.from_epsg(epsg)
-            del crs
-        except exceptions.CRSError as e_info:
-            raise exceptions.CRSError(f"Your EPSG:{epsg} doesn't exist") from e_info
-
-        ProjEngine().set_epsg(epsg, path_geoid)
-
-    # pylint: disable-next=too-many-arguments
+        for idepsg in [*epsg, epsg_output]:
+            if idepsg:
+                try:  # Check if the epsg exist
+                    _ = CRS.from_epsg(idepsg)
+                    del _
+                except exceptions.CRSError as e_info:
+                    raise exceptions.CRSError(f"Your EPSG:{epsg}"
+                                              " doesn't exist in pyproj.") from e_info
+        if epsg_output:
+            self.epsg_output = True
+
+        ProjEngine().set_epsg(epsg, path_geoid, epsg_output)
+
+    # pylint: disable-next=too-many-arguments too-many-positional-arguments
     def add_camera(self, name_camera: str, ppax: float, ppay: float,
                    focal: float, width: int, height: int) -> None:
         """

borea/format/conl.py

@@ -33,19 +33,15 @@ class Conl:
     cam: Camera
     proj: str
 
-    def save_conl(self, path_conical: Path, linalt: bool = True) -> None:
+    def save_conl(self, path_conical: Path) -> None:
         """
         Save the shot as light conical file.
 
         Args:
             path_conical (Path): path to the light conical file.
-            linalt (bool): If you want z shot corrected by linear alteration.
         """
         date_now = datetime.now()
 
-        # Scale factor correction
-        self.shot.set_linear_alteration(linalt)
-
         # creation XML
         ori = ET.Element("orientation", {})
         ET.SubElement(ori, "lastmodificationbylibori",

borea/format/rpc.py

@@ -9,6 +9,7 @@ from borea.datastruct.dtm import Dtm
 from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
 from borea.transform_world_image.transform_shot.world_image_shot import WorldImageShot
 from borea.utils.miscellaneous.miscellaneous import normalize
+from borea.utils.solver.solver import npsolve
 
 
 class Rpc:
@@ -22,6 +23,7 @@ class Rpc:
     def __init__(self) -> None:
         self.param_rpc = {}
         self.fact_rpc = None
+        self.output_epsg = False
 
     @classmethod
     def from_shot(cls, shot: Shot, cam: Camera, param_rpc: dict, unit_data: dict) -> None:
@@ -46,6 +48,7 @@ class Rpc:
         """
         obj = cls()
         obj.fact_rpc = param_rpc["fact_rpc"]
+        obj.output_epsg = param_rpc["epsg_output"]
         obj.param_rpc["ERR_BIAS"] = -1
         obj.param_rpc["ERR_RAND"] = -1
 
@@ -107,9 +110,14 @@ class Rpc:
             tuple: grid image normalize and grid world normalize.
         """
         if self.fact_rpc is None:
-            x_geog, y_geog, z_geog = ProjEngine().carto_to_geog(grid_world[0],
-                                                                grid_world[1],
-                                                                grid_world[2])
+            if self.output_epsg:
+                x_geog, y_geog, z_geog = ProjEngine().tf.proj_to_proj_out(grid_world[0],
+                                                                          grid_world[1],
+                                                                          grid_world[2])
+            else:
+                x_geog, y_geog, z_geog = ProjEngine().tf.carto_to_geog(grid_world[0],
+                                                                       grid_world[1],
+                                                                       grid_world[2])
         else:
             x_geog = grid_world[0]*self.fact_rpc
             y_geog = grid_world[1]*self.fact_rpc
@@ -154,7 +162,7 @@ class Rpc:
             np.array: Rpc coefficients.
         """
         mat_obs = self.setup_matrix_obs_rpc(img_norm, world_norm, polynomial_degree)
-        x = np.linalg.lstsq(mat_obs, img_norm, rcond=None)[0]
+        x = npsolve(mat_obs, img_norm)
 
         coef_rpc = np.zeros(40)
         if polynomial_degree == 1:

borea/geodesy/local_euclidean_proj.py

@@ -37,7 +37,7 @@ class LocalEuclideanProj(EuclideanProj):
         Returns:
             np.array: Transition matrix.
         """
-        lon, lat = ProjEngine().carto_to_geog(x, y)
+        lon, lat = ProjEngine().tf.carto_to_geog(x, y)
         gamma = ProjEngine().get_meridian_convergence(x, y)
 
         # Matrix for switching to local cartesian coordinates
@@ -92,10 +92,10 @@ class LocalEuclideanProj(EuclideanProj):
         """
         coor = check_array_transfo(coor[0], coor[1], coor[2])
 
-        coor_geoc = np.array(ProjEngine().carto_to_geoc(coor[0], coor[1], coor[2]))
-        central_geoc = np.array(ProjEngine().carto_to_geoc(self.pt_central[0],
-                                                           self.pt_central[1],
-                                                           self.pt_central[2]))
+        coor_geoc = np.array(ProjEngine().tf.carto_to_geoc(coor[0], coor[1], coor[2]))
+        central_geoc = np.array(ProjEngine().tf.carto_to_geoc(self.pt_central[0],
+                                                              self.pt_central[1],
+                                                              self.pt_central[2]))
         dr = np.vstack([coor_geoc[0] - central_geoc[0],
                         coor_geoc[1] - central_geoc[1],
                         coor_geoc[2] - central_geoc[2]])
@@ -115,13 +115,13 @@ class LocalEuclideanProj(EuclideanProj):
         """
         coor = np.squeeze(coor)
 
-        central_geoc = np.array(ProjEngine().carto_to_geoc(self.pt_central[0],
-                                                           self.pt_central[1],
-                                                           self.pt_central[2]))
+        central_geoc = np.array(ProjEngine().tf.carto_to_geoc(self.pt_central[0],
+                                                              self.pt_central[1],
+                                                              self.pt_central[2]))
         dr = np.vstack([coor[0] - self.pt_central[0],
                         coor[1] - self.pt_central[1],
                         coor[2] - self.pt_central[2]])
         point_geoc = np.squeeze((self.rot_to_euclidean_local.T @ dr) + np.array([central_geoc]).T)
         x_gc, y_gc, z_gc = check_array_transfo(point_geoc[0], point_geoc[1], point_geoc[2])
-        tup = ProjEngine().geoc_to_carto(x_gc, y_gc, z_gc)
+        tup = ProjEngine().tf.geoc_to_carto(x_gc, y_gc, z_gc)
         return np.array([tup[0], tup[1], tup[2]])

borea/geodesy/proj_engine.py

@@ -11,30 +11,33 @@ from borea.utils.singleton.singleton import Singleton
 
 # pylint: disable=unpacking-non-sequence
 @dataclass
-class ProjEngine(TransformGeodesy, metaclass=Singleton):
+class ProjEngine(metaclass=Singleton):
     """
     This class provides functions for using a cartographic system.
     """
     epsg: int = None
     geoid: list = None
+    epsg_output: int = None
 
     def __post_init__(self) -> None:
         if self.epsg:
-            self.crs = pyproj.CRS.from_epsg(self.epsg)
+            self.crs = pyproj.CRS.from_epsg(self.epsg[0])
             self.proj = pyproj.Proj(self.crs)
-            TransformGeodesy.__tf_init__(self, self.geoid, self.crs)
+            self.tf = TransformGeodesy(self.epsg, self.geoid, self.epsg_output)
 
-    def set_epsg(self, epsg: int, geoid: list = None) -> None:
+    def set_epsg(self, epsg: list, geoid: list = None, epsg_output: int = None) -> None:
         """
         Setter of the class ProjEngine.
         Allows to init the class with data.
 
         Args:
-            epsg (int): Code epsg of the porjection ex: "EPSG:2154".
+            epsg (list): Code epsg of the projection ex: [2154].
             geoid (list): List of geoid to use.
+            epsg_output (int): Code epsg of the output projection. If you want to change.
         """
         self.epsg = epsg
         self.geoid = geoid
+        self.epsg_output = epsg_output
         self.__post_init__()
 
     def get_meridian_convergence(self, x_carto: Union[np.ndarray, List[float], float],
@@ -50,7 +53,7 @@ class ProjEngine(TransformGeodesy, metaclass=Singleton):
         Returns:
             np.array : Meridian convergence in degree.
         """
-        (x_geog, y_geog) = self.carto_to_geog(x_carto, y_carto)
+        (x_geog, y_geog) = self.tf.carto_to_geog(x_carto, y_carto)
         return -np.array(self.proj.get_factors(x_geog, y_geog).meridian_convergence)
 
     def get_scale_factor(self, x_carto: Union[np.ndarray, List[float], float],
@@ -66,5 +69,5 @@ class ProjEngine(TransformGeodesy, metaclass=Singleton):
         Returns:
             np.array: Scale factor and meridian convergence.
         """
-        x_geog, y_geog = self.carto_to_geog(x_carto, y_carto)
+        x_geog, y_geog = self.tf.carto_to_geog(x_carto, y_carto)
         return np.array(self.proj.get_factors(x_geog, y_geog).meridional_scale) - 1

borea/geodesy/transform_geodesy.py

@@ -1,13 +1,12 @@
 """
 Module for class ProjEngine, transform geodesy
 """
-from dataclasses import dataclass
 import pyproj
 import numpy as np
+import pandas as pd
 
 
-# pylint: disable=unsubscriptable-object
-@dataclass
+# pylint: disable=too-many-instance-attributes
 class TransformGeodesy():
     """
     This class provides functions to tranform coordinate system.
@@ -16,50 +15,157 @@ class TransformGeodesy():
 
     Args:
         geoid (list): List of geoid to use.
-        crs (pyproj): CRS pyproj of the worksite.
+        epsg (list): Code epsg of the projection ex: [2154].
+        epsg_output (int): Code epsg of the output projection. If you want to change.
     """
-    carto_to_geoc = None
-    geoc_to_carto = None
-    carto_to_geog = None
-    geog_to_carto = None
-    geog_to_geoid = None
-    geoid_to_geog = None
-
-    def __tf_init__(self, geoid: list, crs: pyproj) -> None:
-        crs_geoc = pyproj.crs.GeocentricCRS(name=crs.name, datum=crs.datum.name)
-        crs_geog = pyproj.crs.GeographicCRS(name=crs.name, datum=crs.datum.name)
-        # Transform cartographic coordinates to geographic coordinates
-        self.carto_to_geog = pyproj.Transformer.from_crs(crs, crs_geog).transform
-        # Transform geographic coordinates to cartographic coordinates
-        self.geog_to_carto = pyproj.Transformer.from_crs(crs_geog, crs).transform
-        # Transform cartographic coordinates to geocentric coordinates
-        self.carto_to_geoc = pyproj.Transformer.from_crs(crs, crs_geoc).transform
-        # Transform geocentric coordinates to cartographic coordinates
-        self.geoc_to_carto = pyproj.Transformer.from_crs(crs_geoc, crs).transform
-
-        if geoid:
-            self.tf_geoid(geoid)
-
-    def tf_geoid(self, geoid: list) -> None:
-        """
-        Create attribute transform, to transform geographic coordinates to geoide coordinates.
+    def __init__(self, epsg: list, geoid: list, epsg_output: int) -> None:
+        self.epsg = epsg
+        self.epsg_output = epsg_output
+        self.crs = pyproj.CRS.from_epsg(epsg[0])
+        self.geoid = geoid
+        self._carto_to_geoc = None
+        self._geoc_to_carto = None
+        self._carto_to_geog = None
+        self._geog_to_carto = None
+        self._geog_to_geoid = None
+        self._geoid_to_geog = None
+        self._proj_to_proj_out = None
 
-        Args:
-            geoid (list): List of geoid to use.
+    @property
+    def carto_to_geog(self) -> pyproj.Transformer:
         """
-        try:
-            # Transform geoide coordinates to geographic coordinates
-            self.geoid_to_geog = pyproj.Transformer.from_pipeline(f"+proj=vgridshift "
-                                                                  f"+grids={','.join(geoid)} "
-                                                                  "+multiplier=1").transform
-            # Transform geographic coordinates to geoide coordinates
-            self.geog_to_geoid = pyproj.Transformer.from_pipeline(f"+proj=vgridshift "
-                                                                  f"+grids={','.join(geoid)} "
-                                                                  "+multiplier=-1").transform
-        except pyproj.exceptions.ProjError as e:
-            raise pyproj.exceptions.ProjError(f"{geoid} The name or path of geotif is incorrect or "
-                                              "does not exist in "
-                                              f"{pyproj.datadir.get_data_dir()}!!!{e}") from e
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : carto_to_geog
+        """
+        if not self._carto_to_geog:
+            try:
+                crs_geog = pyproj.CRS.from_epsg(self.epsg[1])
+            except (IndexError, pyproj.exceptions.CRSError):
+                crs_geog = pyproj.crs.GeographicCRS(name=self.crs.name, datum=self.crs.datum.name)
+
+            self._carto_to_geog = pyproj.Transformer.from_crs(self.crs, crs_geog).transform
+
+        return self._carto_to_geog
+
+    @property
+    def geog_to_carto(self) -> pyproj.Transformer:
+        """
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : geog_to_carto
+        """
+        if not self._geog_to_carto:
+            try:
+                crs_geog = pyproj.CRS.from_epsg(self.epsg[1])
+            except (IndexError, pyproj.exceptions.CRSError):
+                crs_geog = pyproj.crs.GeographicCRS(name=self.crs.name, datum=self.crs.datum.name)
+
+            self._geog_to_carto = pyproj.Transformer.from_crs(crs_geog, self.crs).transform
+
+        return self._geog_to_carto
+
+    @property
+    def carto_to_geoc(self) -> pyproj.Transformer:
+        """
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : carto_to_geoc
+        """
+        if not self._carto_to_geoc:
+            try:
+                crs_geoc = pyproj.CRS.from_epsg(self.epsg[2])
+            except (IndexError, pyproj.exceptions.CRSError):
+                crs_geoc = pyproj.crs.GeocentricCRS(name=self.crs.name, datum=self.crs.datum.name)
+
+            self._carto_to_geoc = pyproj.Transformer.from_crs(self.crs, crs_geoc).transform
+
+        return self._carto_to_geoc
+
+    @property
+    def geoc_to_carto(self) -> pyproj.Transformer:
+        """
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : geoc_to_carto
+        """
+        if not self._geoc_to_carto:
+            try:
+                crs_geoc = pyproj.CRS.from_epsg(self.epsg[2])
+            except (IndexError, pyproj.exceptions.CRSError):
+                crs_geoc = pyproj.crs.GeocentricCRS(name=self.crs.name, datum=self.crs.datum.name)
+
+            self._geoc_to_carto = pyproj.Transformer.from_crs(crs_geoc, self.crs).transform
+
+        return self._geoc_to_carto
+
+    @property
+    def geoid_to_geog(self) -> pyproj.Transformer:
+        """
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : geoid_to_geog
+        """
+        if not self.geoid:
+            raise ValueError("Mistake Geoid path")
+
+        if not self._geoid_to_geog:
+            try:
+                # Transform geoide coordinates to geographic coordinates
+                self._geoid_to_geog = pyproj.Transformer.from_pipeline("+proj=vgridshift "
+                                                                       "+grids="
+                                                                       f"{','.join(self.geoid)} "
+                                                                       "+multiplier=1").transform
+            except pyproj.exceptions.ProjError as e:
+                raise pyproj.exceptions.ProjError(f"{self.geoid} The name or path "
+                                                  "of geotif is incorrect or does not exist in "
+                                                  f"{pyproj.datadir.get_data_dir()}!!!{e}") from e
+
+        return self._geoid_to_geog
+
+    @property
+    def geog_to_geoid(self) -> pyproj.Transformer:
+        """
+        Returns the transformation or instantiates it before returning it.
+
+        Returns:
+            pyproj.Transformer : geog_to_geoid
+        """
+        if not self.geoid:
+            raise ValueError("Mistake Geoid path")
+
+        if not self._geog_to_geoid:
+            try:
+                # Transform geoide coordinates to geographic coordinates
+                self._geog_to_geoid = pyproj.Transformer.from_pipeline("+proj=vgridshift "
+                                                                       "+grids="
+                                                                       f"{','.join(self.geoid)} "
+                                                                       "+multiplier=-1").transform
+            except pyproj.exceptions.ProjError as e:
+                raise pyproj.exceptions.ProjError(f"{self.geoid} The name or path "
+                                                  "of geotif is incorrect or does not exist in "
+                                                  f"{pyproj.datadir.get_data_dir()}!!!{e}") from e
+
+        return self._geog_to_geoid
+
+    @property
+    def proj_to_proj_out(self) -> pyproj.Transformer:
+        """
+        Create the pyproj Transformer from crs of worksite to crs geographic ask.
+
+        Returns:
+            pyproj.Transformer : carto_to_geog_out
+        """
+        if not self._proj_to_proj_out:
+            crs_out = pyproj.CRS.from_epsg(self.epsg_output)
+            self._proj_to_proj_out = pyproj.Transformer.from_crs(self.crs, crs_out).transform
+
+        return self._proj_to_proj_out
 
     def tranform_height(self, coor: np.ndarray) -> float:
         """
@@ -83,7 +189,7 @@ class TransformGeodesy():
             raise ValueError("The geoid has not been entered, "
                              "cannot transform z altitude to height.") from info
 
-        if new_z == np.inf:
+        if np.all(new_z == np.inf):
             raise ValueError("out geoid")
         return new_z
 
@@ -112,3 +218,23 @@ class TransformGeodesy():
         if np.all(new_z == np.inf):
             raise ValueError("out geoid")
         return new_z
+
+    def transform_pt_proj(self, df_pt: pd.DataFrame, type_z_input: str = None,
+                          type_z_output: str = None) -> pd.DataFrame:
+        """
+        Tranform the input projection to the output projection of points coordinates
+        """
+        if type_z_input and type_z_output:
+            if type_z_input != type_z_output:
+                if type_z_output == "altitude":
+                    df_pt["z"] = self.tranform_altitude(np.array([df_pt['x'],
+                                                                  df_pt['y'],
+                                                                  df_pt['z']]))
+                if type_z_output == "height":
+                    df_pt["z"] = self.tranform_height(np.array([df_pt['x'],
+                                                                df_pt['y'],
+                                                                df_pt['z']]))
+
+        df_pt["x"], df_pt["y"] = self.proj_to_proj_out(df_pt['x'], df_pt['y'])
+
+        return df_pt

borea/process/p_add_data/p_gen_param.py

@@ -2,8 +2,8 @@
 Args of parser for reading generals parameters
 """
 import argparse
-import pyproj
 from borea.worksite.worksite import Worksite
+from borea.process.p_add_data.p_proj import args_proj_param, process_args_proj_param
 from borea.reader.reader_camera import read_camera
 
 
@@ -17,14 +17,7 @@ def args_general_param(parser: argparse) -> argparse:
     Returns:
         argsparse: Parser with argument.
     """
-    parser.add_argument('-e', '--epsg',
-                        type=int, default=None,
-                        help='EPSG codifier number of the reference system used e.g. "2154".')
-    parser.add_argument('-y', '--pathgeoid',
-                        type=str, nargs='*', default=None,
-                        help='Path to the pyproj GeoTIFF of the geoid e.g../test/data/geoid.tif'
-                             f' or they must be in {pyproj.datadir.get_data_dir()} and just'
-                             ' need name of file e.g. geoid.tif.')
+    parser = args_proj_param(parser)
     parser.add_argument('-c', '--camera',
                         type=str, nargs='*',
                         help='Files paths of cameras (xml or txt).')
@@ -52,11 +45,7 @@ def process_args_gen_param(args: argparse, work: Worksite) -> Worksite:
         Worksite: data
     """
     # Add a projection to the worksite
-    if args.epsg is not None:
-        work.set_proj(args.epsg, args.pathgeoid)
-        print(f"Projection set-up with EPSG:{args.epsg}.")
-    else:
-        print("There is no given projection.")
+    work = process_args_proj_param(args, work)
 
     # Reading camera file
     if args.camera is not None:

borea/process/p_add_data/p_proj.py

@@ -0,0 +1,57 @@
+"""
+Args of parser for reading projection parameters
+"""
+import argparse
+import pyproj
+from borea.worksite.worksite import Worksite
+
+
+def args_proj_param(parser: argparse) -> argparse:
+    """
+    Args for adding projection parameter.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-e', '--epsg',
+                        type=int, default=None,
+                        help='EPSG codifier number of the reference system used e.g. "2154".')
+    parser.add_argument('-y', '--pathgeoid',
+                        type=str, nargs='*', default=None,
+                        help='Path to the pyproj GeoTIFF of the geoid e.g../test/data/geoid.tif'
+                             f' or they must be in {pyproj.datadir.get_data_dir()} and just'
+                             ' need name of file e.g. geoid.tif.')
+    parser.add_argument('--geog', '--epsg_geographic',
+                        type=int, default=None,
+                        help='EPSG codifier number of the reference geographic system.')
+    parser.add_argument('--geoc', '--epsg_geocentric',
+                        type=int, default=None,
+                        help='EPSG codifier number of the reference geocentric system.')
+    parser.add_argument('--oe', '--epsg_output',
+                        type=int, default=None,
+                        help="Code epsg of output Data")
+    return parser
+
+
+def process_args_proj_param(args: argparse, work: Worksite) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Worksite to work on.
+
+    Returns:
+        Worksite: data
+    """
+    # Add a projection to the worksite
+    if args.epsg is not None:
+        work.set_proj([args.epsg, args.geog, args.geoc], args.pathgeoid, args.oe)
+        print(f"Projection set-up with EPSG:{args.epsg}.")
+    else:
+        print("There is no given projection.")
+
+    return work

borea/process/p_add_data/p_unit_shot.py

@@ -36,13 +36,13 @@ def args_output_shot(parser: argparse) -> argparse:
     Returns:
         argsparse: Parser with argument.
     """
-    parser.add_argument('-ob', '--order_axe_output',
+    parser.add_argument('--ob', '--order_axe_output',
                         type=str, default=None,
                         help="Order of rotation matrix axes you want in output.")
-    parser.add_argument('-ou', '--output_unit_angle',
+    parser.add_argument('--ou', '--output_unit_angle',
                         type=str, default=None, choices=["degree", "radian", None],
                         help="Unit of the angle of shooting, 'degree' or 'radian'")
-    parser.add_argument('-oa', '--output_linear_alteration',
+    parser.add_argument('--oa', '--output_linear_alteration',
                         type=bool, default=None,
                         help="True if z shot corrected by linear alteration.")
     return parser