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

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

@@ -22,6 +22,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 +47,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 +109,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

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

borea/process/p_format/p_write_opk.py

@@ -45,8 +45,8 @@ def process_args_write_opk(args: argparse, work: Worksite) -> None:
         args (argparse): Arg to apply on worksite (data).
         work (Worksite): Data.
     """
-    if args.order_axe_output:
-        args.order_axe_output = args.order_axe_output.lower()
+    if args.ob:
+        args.ob = args.ob.lower()
 
     if args.output_header:
         args.output_header = list(args.output_header.upper())
@@ -54,10 +54,10 @@ def process_args_write_opk(args: argparse, work: Worksite) -> None:
     # Writing data
     print("Writing OPK.")
     if args.namereturn is not None:
-        args_writing = {"order_axe": args.order_axe_output,
+        args_writing = {"order_axe": args.ob,
                         "header": args.output_header,
-                        "unit_angle": args.output_unit_angle,
-                        "linear_alteration": args.output_linear_alteration}
+                        "unit_angle": args.ou,
+                        "linear_alteration": args.oa}
         manager_writer("opk", args.namereturn, args.pathreturn, args_writing, work)
         print(f"File written in {args.pathreturn + args.namereturn}.opk.")
     else:

borea/process/p_func/p_spaceresection.py

@@ -44,8 +44,8 @@ def process_space_resection(args: argparse) -> Worksite:
     work = Worksite("Space_Resection")
     work = process_args_gen_param(args, work)
     work.set_type_z_shot(check_header_file(list(args.output_header.upper()))[1])
-    pt2d = read_file_pt_dataframe(args.gcp2d, list(args.head_gcp2d.upper()), "pt2d")
-    pt3d = read_file_pt_dataframe(args.gcp3d, list(args.head_gcp3d.upper()), "pt3d")
+    pt2d, _ = read_file_pt_dataframe(args.gcp2d, list(args.head_gcp2d.upper()), "pt2d")
+    pt3d, _ = read_file_pt_dataframe(args.gcp3d, list(args.head_gcp3d.upper()), "pt3d")
     pinit = {"coor_init": np.array(args.point3d)}
     SpaceResection(work).space_resection_to_worksite(pt2d, pt3d, pinit)
     return work

borea/process/p_func/p_tf_proj_pt.py

@@ -0,0 +1,50 @@
+"""
+Args of parser to transform projection of 3D points.
+"""
+import argparse
+
+from borea.process.p_add_data.p_file_gcp3d import args_gcp3d
+from borea.process.p_add_data.p_proj import args_proj_param
+from borea.process.p_add_data.p_write import args_writer
+from borea.reader.reader_point import read_file_pt_dataframe
+from borea.geodesy.proj_engine import ProjEngine
+from borea.writer.writer_df_to_txt import write_df_to_txt
+
+
+def args_tf_proj_param(parser: argparse) -> argparse:
+    """
+    Args for adding transform proj of points parameter.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser = args_gcp3d(parser)
+    parser = args_proj_param(parser)
+    parser.add_argument('--oz', '--z_output',
+                        type=str, choices=[None, 'altitude', 'height'], default=None,
+                        help="Output type of z. altitude or height")
+    parser = args_writer(parser)
+    return parser
+
+
+def process_tf_proj_param(args: argparse) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+    """
+    # Read file to Dataframe
+    df, type_z = read_file_pt_dataframe(args.gcp3d, args.head_gcp3d, "pt3d")
+
+    # Setup Projection
+    ProjEngine().set_epsg([args.epsg, args.geog, args.geoc], args.pathgeoid, args.oe)
+
+    # Change projection
+    new_df = ProjEngine().tf.transform_pt_proj(df, type_z, args.oz)
+
+    # Write the new file
+    write_df_to_txt(args.namereturn, args.pathreturn, new_df)

borea/reader/orientation/reader_opk.py

@@ -50,9 +50,9 @@ def read(file: Path, args: dict, work: Worksite) -> Worksite:
             file_opk.close()
     except FileNotFoundError as e:
         raise FileNotFoundError(f"The path {file} is incorrect !!! "
-                                f"or your os is {platform.system()}."
-                                "For Windows path is \\,"
-                                " for Linux and MacOS (Darwin) is / .") from e
+                                f"or your os is {platform.system()}. "
+                                "For Windows path is \\, "
+                                "for Linux and MacOS (Darwin) is / .") from e
 
     work.type_z_shot = type_z
     return work

borea/reader/reader_point.py

@@ -53,7 +53,7 @@ def read_file_pt(path: str, header: list, type_point: str, work: Worksite) -> No
         raise FileNotFoundError(f"The path {path} is incorrect !!!") from e
 
 
-def read_file_pt_dataframe(path: str, header: list, type_point: str) -> pd.DataFrame:
+def read_file_pt_dataframe(path: str, header: list, type_point: str) -> tuple:
     """
     Read file of points to save in Dataframe.
 
@@ -63,12 +63,12 @@ def read_file_pt_dataframe(path: str, header: list, type_point: str) -> pd.DataF
         type_point (str): Type of point is reading (pt2d, pt3d).
 
     Returns:
-        pd.Dataframe: Dataframe of data.
+        tuple: Dataframe of data and type of z in str.
     """
     if type_point not in ["pt2d", "pt3d"]:
         raise ValueError(f"type {type_point} in incorrect. ['pt2d', 'pt3d']")
 
-    header, _ = check_header_file(header, type_point)
+    header, type_z = check_header_file(header, type_point)
 
     id_pt = []
     ttype = []
@@ -110,4 +110,4 @@ def read_file_pt_dataframe(path: str, header: list, type_point: str) -> pd.DataF
                            "id_shot": ttype,
                            "column": coor[:, 0],
                            "line": coor[:, 1]})
-    return df
+    return df, type_z

borea/transform_world_image/transform_shot/conversion_coor_shot.py

@@ -28,9 +28,9 @@ def conv_z_shot_to_z_data(shot: Shot, type_z_shot: str, type_z_data: str,
 
     if type_z_shot != type_z_data:
         if type_z_shot == "height":
-            new_z = ProjEngine().tranform_altitude(pos_shot)
+            new_z = ProjEngine().tf.tranform_altitude(pos_shot)
         else:
-            new_z = ProjEngine().tranform_height(pos_shot)
+            new_z = ProjEngine().tf.tranform_height(pos_shot)
         pos_shot[2] = new_z
 
     return pos_shot
@@ -51,8 +51,8 @@ def conv_output_z_type(coor: np.ndarray, type_z_input: str, type_z_output: str)
     new_z = coor[2]
     if type_z_input != type_z_output:
         if type_z_input == "height":
-            new_z = ProjEngine().tranform_altitude(coor)
+            new_z = ProjEngine().tf.tranform_altitude(coor)
         else:
-            new_z = ProjEngine().tranform_height(coor)
+            new_z = ProjEngine().tf.tranform_height(coor)
 
     return np.array([coor[0], coor[1], new_z])

borea/transform_world_image/transform_shot/image_world_shot.py

@@ -37,7 +37,7 @@ class ImageWorldShot():
         Returns:
             np.array: Cartographique coordinate [x,y,z].
         """
-        if type_z_data != type_z_shot and not ProjEngine().geog_to_geoid:
+        if type_z_data != type_z_shot and not ProjEngine().tf.geog_to_geoid:
             raise ValueError("Missing geoid")
 
         if not Dtm().path_dtm:

borea/transform_world_image/transform_shot/world_image_shot.py

@@ -34,7 +34,7 @@ class WorldImageShot():
         Returns:
             np.array: The image coordinate [c,l].
         """
-        if type_z_data != type_z_shot and not ProjEngine().geog_to_geoid:
+        if type_z_data != type_z_shot and not ProjEngine().tf.geog_to_geoid:
             raise ValueError("Missing geoid")
 
         if self.shot.linear_alteration and not Dtm().path_dtm and not self.shot.approxeucli:

borea/transform_world_image/transform_worksite/image_world_least_square.py

@@ -150,7 +150,7 @@ class WorldLeastSquare:
         """
         v_res = np.zeros(nbr_obs)
         coord_i, coord_j, data = [], [], []
-        for _, (id_shot, pd_data) in enumerate(pd_mes_temp.groupby('id_img')):
+        for id_shot, pd_data in pd_mes_temp.groupby('id_img'):
             shot = self.work.shots[id_shot]
             cam = self.work.cameras[shot.name_cam]
 

borea/worksite/worksite.py

@@ -173,8 +173,10 @@ class Worksite(Workdata):
                                                                    self.type_z_shot, False)[2]
                 shot.set_z_nadir(z_nadir)
 
-    def set_unit_shot(self, type_z: str = None, unit_angle: str = None,
-                      linear_alteration: bool = None, order_axe: str = None) -> None:
+    # pylint: disable-next=too-many-arguments too-many-positional-arguments
+    def set_unit_output(self, type_z: str = None, unit_angle: str = None,
+                        linear_alteration: bool = None, order_axe: str = None,
+                        proj_output: bool = True) -> None:
         """
         Allows you to change unit or parameter of shots.
 
@@ -183,6 +185,7 @@ class Worksite(Workdata):
             unit_angle (str): Unit angle you want.
             linear_alteration (bool): True if you want data corrected.
             order_axe (str): Order of rotation matrice you want in your angle.
+            proj_output (bool): True to change the projection of shot.
         """
         if unit_angle not in ["degree", "radian", None]:
             raise ValueError(f"unit_angle: {unit_angle} is not recognized,"
@@ -198,14 +201,16 @@ class Worksite(Workdata):
             self.type_z_shot = type_z
 
         for shot in self.shots.values():
-            if unit_angle is not None:
+            if unit_angle:
                 shot.set_unit_angle(unit_angle)
-            if type_z is not None:
+            if type_z:
                 shot.set_type_z(type_z)
             if linear_alteration is not None:
                 shot.set_linear_alteration(linear_alteration)
-            if order_axe is not None:
+            if order_axe:
                 shot.set_order_axe(order_axe)
+            if self.epsg_output and proj_output:
+                shot.set_proj_pos()
 
     def calculate_barycentre(self) -> np.ndarray:
         """

borea/writer/writer_con.py

@@ -20,7 +20,14 @@ def write(name: str, folder_con: str, param_con: dict, work: Worksite) -> None:
         work (Worksite): The site to be recorded.
     """
     _, _ = name, param_con
-    geoview_proj = search_info("EPSG", str(ProjEngine().epsg), "GEOVIEW")
+
+    if work.epsg_output:
+        epsg_output = ProjEngine().epsg_output
+    else:
+        epsg_output = ProjEngine().epsg[0]
+
+    work.set_unit_output(type_z="altitude", linear_alteration=True)
+    geoview_proj = search_info("EPSG", str(epsg_output), "GEOVIEW")
 
     for name_shot, shot in work.shots.items():
         cam = work.cameras[shot.name_cam]

borea/writer/writer_opk.py

@@ -35,7 +35,7 @@ def write(name_opk: str, path_opk: str, args: dict, work: Worksite) -> None:
     if "S" in header:
         raise ValueError("Letter S doesn't existe in writing header opk.")
 
-    work.set_unit_shot(type_z, args["unit_angle"], args["linear_alteration"], args["order_axe"])
+    work.set_unit_output(type_z, args["unit_angle"], args["linear_alteration"], args["order_axe"])
 
     header_file = ""
     for i in header:

borea/writer/writer_rpc.py

@@ -20,6 +20,7 @@ def write(name: str, folder_rpc: str, param_rpc: dict, work: Worksite) -> None:
         "size_grid"; size of the grip to calcule rpc.
         "order"; order of the polynome of the rpc.
         "fact_rpc"; rpc factor for world coordinate when src is not WGS84.
+        "epsg_output"; code epsg for RPC.
         work (Worksite): The site to be recorded.
     """
     _ = name
@@ -28,7 +29,9 @@ def write(name: str, folder_rpc: str, param_rpc: dict, work: Worksite) -> None:
             "SAMP_SCALE", "LAT_SCALE", "LONG_SCALE",
             "HEIGHT_SCALE"]
 
-    work.set_unit_shot(type_z=Dtm().type_dtm)
+    param_rpc["epsg_output"] = work.epsg_output
+
+    work.set_unit_output(type_z=Dtm().type_dtm, proj_output=False)
 
     for name_shot, shot in work.shots.items():
         cam = work.cameras[shot.name_cam]

borea_tools/spaceresection_opk.py

@@ -13,8 +13,8 @@ from borea.process.p_format.p_write_opk import args_writing_opk, process_args_wr
 
 def spaceresection_opk():
     """
-    Permet d'obtenir un fichier OPK à partir de point de liaison sur les images et de leur
-    coordonnées terrain (calcule les 6 paramètres externes pour chaque image qui dispose d'un point)
+    Produces an OPK file from image link points and their field coordinates
+    coordinates (calculates the 6 external parameters for each image with a point)
     """
     parser = argparse.ArgumentParser(description='Space resection of point file image and world'
                                                  ' to calculate 6 externals parameters of shots')

borea_tools/transform_proj_points.py

@@ -0,0 +1,30 @@
+"""
+Main to transform projection of 3D points.
+"""
+# pylint: disable=import-error, wrong-import-position, line-too-long
+import argparse
+import sys
+import os
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+from borea.process.p_func.p_tf_proj_pt import args_tf_proj_param, process_tf_proj_param  # noqa: E402, E501
+
+
+def transform_proj_pt():
+    """
+    Transforms the projection of a point file by pyproj.
+    """
+    parser = argparse.ArgumentParser(description='Transform coordinate projection of the 3D points'
+                                                 ' file.')
+
+    # Args
+    parser = args_tf_proj_param(parser)
+
+    args = parser.parse_args()
+
+    # Process data
+    process_tf_proj_param(args)
+
+
+if __name__ == "__main__":
+    transform_proj_pt()

{ign_borea-0.1.5.dist-info → ign_borea-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ign-borea
-Version: 0.1.5
+Version: 0.2.1
 Summary: A package to manipulate orientation files
 Author-email: Antoine Cornu <antoine.cornu@ign.fr>, Nicolas Laurain <nicolas.laurain@ign.fr>
 License: MIT License
@@ -53,8 +53,6 @@ Requires-Dist: dataclasses ; extra == 'dev'
 Requires-Dist: pyproj ; extra == 'dev'
 Requires-Dist: scipy ; extra == 'dev'
 Requires-Dist: pandas ; extra == 'dev'
-Requires-Dist: build ; extra == 'dev'
-Requires-Dist: twine ; extra == 'dev'
 
 [![IGNF badge](https://img.shields.io/badge/IGNF-8cbd3a)](https://www.ign.fr/) [![PyPI Downloads](https://img.shields.io/pypi/dm/ign-borea.svg?label=PyPI%20downloads)](
 https://pypi.org/project/ign-borea/)
@@ -101,6 +99,7 @@ Some tools are already implemented in the library:
 * Transforms coordinates file terrain from image: `ptfile-image-to-world -h` [doc](https://github.com/IGNF/Borea/tree/main/borea_tools/docs_tools/README_ptfile_image_to_world.md)
 * Transforms coordinates file image from terrain: `ptfile-world-to-image -h` [doc](https://github.com/IGNF/Borea/tree/main/borea_tools/docs_tools/README_ptfile_world_to_image.md)
 * Calculates opk by space resection: `spaceresection-opk -h` [doc](https://github.com/IGNF/Borea/tree/main/borea_tools/docs_tools/README_spaceresection_opk.md)
+* Transform projection of points file: `transform-proj-points -h` [doc](./borea_tools/docs_tools/README_transform_proj_points.md)
 
 ## Read data and instantiate worksite
 

{ign_borea-0.1.5.dist-info → ign_borea-0.2.1.dist-info}/RECORD

@@ -3,17 +3,17 @@ borea/datastruct/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 borea/datastruct/camera.py,sha256=78cOKiqm08HRWFNHFJsL-egiDFxEsB74AtI-BWsFEqQ,660
 borea/datastruct/dtm.py,sha256=qsoH7wJGbolyRIMd7q8FI9Xk-8TwQo9dBvI79lbaJIU,3998
 borea/datastruct/gcp.py,sha256=cXDGPAAIpHWI0Wq8VexAqcodg7GmdtDbVeWXjzOYuAs,544
-borea/datastruct/shot.py,sha256=sQBIjqQvgn-5kT_8XuuB5PyY2fQBQqhtISbsX0Tt44A,8907
-borea/datastruct/workdata.py,sha256=N97vsxEVVS9kroIBD9jNx1mSqreKPS077W20BYzAS04,8394
+borea/datastruct/shot.py,sha256=kYvCSuKRntIMAXaJX75jaMIJJdWEFLAjV-bCWWHWV8g,9160
+borea/datastruct/workdata.py,sha256=xTt-3P1l90q_EPL__TRBFz5zl6U2UXEDPPAct0gRWQ8,8844
 borea/format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-borea/format/conl.py,sha256=jWHrm-8KYuG3YDvKP_fgrr8h9sw0PoHHrReKqS1WZ2U,4949
-borea/format/rpc.py,sha256=_NVl9Q3qpqTL17NpBtc8H5tRPx5cZZh6tEywCKzq04E,10939
+borea/format/conl.py,sha256=mYzDO2A8BoEBMSlok5iUvzoADHMMywgq4iE_l1S_1Jg,4767
+borea/format/rpc.py,sha256=T5IAv6USqb8mdgao427cL1qyvJC5SdHS2H080f7Mbcs,11362
 borea/geodesy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/geodesy/approx_euclidean_proj.py,sha256=0X3BHKeK0YPBFRjpRkyEtI-unXljzjcXRKGADHAN3dY,3235
 borea/geodesy/euclidean_proj.py,sha256=VSPckwZAvem4z6SQhdacjwC4XbcucNjA6gWEjBVBEJY,684
-borea/geodesy/local_euclidean_proj.py,sha256=o7G9gEdhUvXNjlVxYrarOT3MfIteDWfUm8Go2oklwZI,5351
-borea/geodesy/proj_engine.py,sha256=5Lu3w4c_pscWxFWjPu9xA4PPgKA5aY19JseYfdfsEXs,2484
-borea/geodesy/transform_geodesy.py,sha256=alCMCuHmjoe6q59SEvAdZNAWTS6d2DyGCpIeV3IcYFU,4661
+borea/geodesy/local_euclidean_proj.py,sha256=iMAL__CwkD26gw8wy5hPJR-FijnK6BUcutgqUAUNXFQ,5378
+borea/geodesy/proj_engine.py,sha256=ORNVC0h5DjCNFEzuRpX2rGAYXuiByqCac3Qc79d8buE,2665
+borea/geodesy/transform_geodesy.py,sha256=MCHPgXt3aTiEkY6SiNY_LeHvyYrdffhSq51xZbgM58o,9298
 borea/geodesy/projectionlist/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/geodesy/projectionlist/search_proj.py,sha256=Qnu6n8hJxnLi72DY5n2jWMo5p8jU_bENY-hWgHnrlnM,1820
 borea/process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,39 +21,41 @@ borea/process/p_add_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 borea/process/p_add_data/p_add_shot.py,sha256=wrjYxJH3bcMfPhQ2ns6jy2uYYXFPnJfTRvDWav1OmqY,1918
 borea/process/p_add_data/p_file_gcp2d.py,sha256=lNYNSck-FIjnQ2AKAFVGvvNLxgcoCB0IJ25uAyAfCGI,1652
 borea/process/p_add_data/p_file_gcp3d.py,sha256=iGcIZU6lCIl0FqR_pE2zDeSbHLqEIvmfnM87A6d4p2k,1632
-borea/process/p_add_data/p_gen_param.py,sha256=SlS_Lr7txhOZPDf8oWe6q4SpnEH-7QHWvKOdEEt1pHg,2560
+borea/process/p_add_data/p_gen_param.py,sha256=SwuIASSAyel2G_MkFFRh8VSWj0sspBUtUdr0SKP9XuE,1976
+borea/process/p_add_data/p_proj.py,sha256=PaiyVqcDpAdmHIa7dNetv6oUJ7l607278kGgRlrB7tw,2018
 borea/process/p_add_data/p_pt2d.py,sha256=g0L_fY8dkVbM17-jut75I9FXvUOfnrrlcT5VQu26aUQ,1696
 borea/process/p_add_data/p_pt3d.py,sha256=wAY5o8_i76UG9qwfcseiOI09h0ONiRmvOeimPqtiyTw,1681
-borea/process/p_add_data/p_unit_shot.py,sha256=ndfpWSZWI1u6ocFXXOgGldXjeK3Ez9Nkj3FXoaqk11s,1678
+borea/process/p_add_data/p_unit_shot.py,sha256=VkfXhSY9XxOLzOxWJCNyR-10mb8Y2VYbEUIKmNlswbQ,1681
 borea/process/p_add_data/p_write.py,sha256=QULk-09Wj9AZDX_ciJeACdzL2t2VGcZFp4HwnCVSdY0,570
 borea/process/p_format/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/process/p_format/p_read_opk.py,sha256=okG3inUF0m2u-8Fepvv_bFpXIIEPAvQCISDpqdm7iAc,3178
 borea/process/p_format/p_write_con.py,sha256=u6NjwGOHcfsAA_JZsh_E-5UU_xYvJrr3QyLGNnhmfCQ,977
-borea/process/p_format/p_write_opk.py,sha256=U4tO15piLUl2zuK3FB_uBd1hUsxVEzJjyL1GGZgynKw,2318
+borea/process/p_format/p_write_opk.py,sha256=fhBp4Jp9QLK2AsEr9i-zRq_UAfHir7iomaM15p2XDIA,2225
 borea/process/p_format/p_write_rpc.py,sha256=Tzt5DJvetbDpr6DlW9CtqzVAJQtcevBMIPtJ087D6F8,1584
 borea/process/p_func/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/process/p_func/p_control.py,sha256=A-SqLnePn6jiqQlmDaTdvyVAazHd59LtCN6UQgleiIQ,2440
 borea/process/p_func/p_image_world.py,sha256=gUPdwm-5cNb6RgxGTnxxU8dnGVQHiddXVhqD6xf0b7U,1663
-borea/process/p_func/p_spaceresection.py,sha256=SBRAn4OGL7gIxYEgwQj1mkgsZtY73yFXWbuSibFiaTg,1721
+borea/process/p_func/p_spaceresection.py,sha256=-VPtXXrZ4hfuM0KjLgNtbQn0ZJAbK0w21V0wdTdBLGs,1727
+borea/process/p_func/p_tf_proj_pt.py,sha256=DH8C37IynzaRtOb4I1PnJRrwH4NyNPCKjGN96W0rqj4,1556
 borea/process/p_func/p_world_image.py,sha256=8vD7J93ze305I4zMkzZhUOlFacJRaS9w9ILIUR_44-Y,1569
 borea/reader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/reader/reader_camera.py,sha256=xBAJTMdXbPZTD_DvH83WEB7Jx808mTu_ZmmdVsrdYck,1606
-borea/reader/reader_point.py,sha256=jZXjw-eof25gvlxQKw8Oj34ecL03JpwkcbOVud71MMQ,4453
+borea/reader/reader_point.py,sha256=aRmvyTYC-McZGKI1NPpHoGcAeHrYCanPdLO1La-3vFI,4473
 borea/reader/orientation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/reader/orientation/manage_reader.py,sha256=Q7MATjkQtCKdb1vU6FOYXdfoViipakq2Sm30sQcMO7c,986
-borea/reader/orientation/reader_opk.py,sha256=XPeVKK3FktRZX4zINndIeDhRH9gvBhtwfe_lHkAUDYY,2798
+borea/reader/orientation/reader_opk.py,sha256=zsNwzPzGOu4aqvrN_Q3yQhrEbyqQcNo92Vp9nfmWQ-c,2799
 borea/stat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/stat/statistics.py,sha256=846GkzmOwyTUvZInuVk04xFo74I70TWgJ1QShoXabi0,9434
 borea/transform_world_image/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/transform_world_image/transform_dtm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/transform_world_image/transform_dtm/world_image_dtm.py,sha256=0tRMnFY0eqo8wggOnEd_VANy7g8WIrUZNnhY-RFAJnU,1335
 borea/transform_world_image/transform_shot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-borea/transform_world_image/transform_shot/conversion_coor_shot.py,sha256=QKAvdOZeGui_xIwV6-SKuLAHNwVcIOtWvPbsz5Ec-lY,1864
-borea/transform_world_image/transform_shot/image_world_shot.py,sha256=AAJQkfcIizFGLVTwPPYwpYt3CmmGFfaTPnIHb1ErGSs,6003
-borea/transform_world_image/transform_shot/world_image_shot.py,sha256=eMKL8LIOVZRMirkFc9eaRWIO-UaWQDX0rDS7Xl2yLss,4555
+borea/transform_world_image/transform_shot/conversion_coor_shot.py,sha256=7DNOZ7PXk0DMmA3HMoWTms5kmsxlHEHPuFD5rwzOhYo,1876
+borea/transform_world_image/transform_shot/image_world_shot.py,sha256=JF2k9GP6Iz1lnUgwMnGufkz97IQyeAIfYosPx0-_8bw,6006
+borea/transform_world_image/transform_shot/world_image_shot.py,sha256=tSCzLdDo_R31wluetDm3uulv1uCxGAqGxBFyqKGMXS0,4558
 borea/transform_world_image/transform_worksite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/transform_world_image/transform_worksite/image_world_intersection.py,sha256=EWFy65qcPQ4yG4h_EHrQvk6aWFuB9ukpm2kgiOveGC8,6440
-borea/transform_world_image/transform_worksite/image_world_least_square.py,sha256=4W37TC3O0XKw3LpIjj3IyRYbNOjDq99zntkXbXPbgEs,7942
+borea/transform_world_image/transform_worksite/image_world_least_square.py,sha256=9APLwtmRE6D3F_RZr_nK7bdxg6LwfzEiUYgefgSap5I,7926
 borea/transform_world_image/transform_worksite/image_world_work.py,sha256=bK6IoffN_lnVfwFHUBKBA8A5blBNeWzT7voatVtfLaA,2037
 borea/transform_world_image/transform_worksite/space_resection.py,sha256=bdhDz9zNISdfGm2JQRE2khghPE4DAXj-i3f8pCzQ6ss,14595
 borea/transform_world_image/transform_worksite/world_image_work.py,sha256=2bHIIINEumFD1GvU2bdOi8V9bTvMCBKwCIzxFNR796c,1721
@@ -73,13 +75,13 @@ borea/utils/singleton/singleton.py,sha256=nTPEI033sYMmVDHBfLgcHdpBFmkU-gidpKPrmQ
 borea/utils/xml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/utils/xml/xml.py,sha256=zHW8p1HmSVp_L-Yu0SGqsTHrJptnG3LdARyjUDxHUpY,1671
 borea/worksite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-borea/worksite/worksite.py,sha256=cYuO-BERHyruOwDkkS3Fe4fGlyAkSI_i1YyFH5idPv0,9114
+borea/worksite/worksite.py,sha256=8sEhjWQRaU8rkMwzRo5WDeqUzVmN0xWnxDW7GizFzFU,9364
 borea/writer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea/writer/manage_writer.py,sha256=ukOHO4zfIQG-bJoi_rw85LIAjIsfcI1lJIQi9b2CTcs,799
-borea/writer/writer_con.py,sha256=lGeZ0hhnRwdDUle0Qp9Ibj6QdQsWXFJm8kqcU33Foko,1000
+borea/writer/writer_con.py,sha256=hm2ewKLP4-B0abg6Q6Mq_5ktuwQwaveGB2sazKG5Jqs,1189
 borea/writer/writer_df_to_txt.py,sha256=kr5DXbOGEqhoonYf9rQqQkku5k0nAenNoC3zE0pZDYQ,938
-borea/writer/writer_opk.py,sha256=zGeDz7ItMGlCLZp-XPBlH3mkwmfrB3bt2ROH96-BiLc,2650
-borea/writer/writer_rpc.py,sha256=qoTu6OKyP0nqMsojAGhuSXrg_HptBUCceIGwzUNzMWY,2116
+borea/writer/writer_opk.py,sha256=WLy4uxaXiHtKACteieZm9QifBMjZki1z9bxlhV1RFAE,2652
+borea/writer/writer_rpc.py,sha256=13M0zPvVCGG8HpiYDYYKzUq_jQGVG8yuChO43e2-TYU,2228
 borea_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 borea_tools/opk_control.py,sha256=jU6CitB1WzmKc_uT5GbdmXeYlHwvtnzKD7gcNv_XKTY,907
 borea_tools/opk_to_conl.py,sha256=iX7f1f6KR-cVQxMYimfKmZVtUnuYFRpmUDH1bzZFZjQ,1054
@@ -89,10 +91,11 @@ borea_tools/pt_image_to_world.py,sha256=6_7ShQNu-FmNKNZHKdktXQJkNyxZGA2luF9zZYx6
 borea_tools/pt_world_to_image.py,sha256=4WV19794N3fNhz5P32Bl8Fc1nczJqpQdY_IITV20kqs,948
 borea_tools/ptfile_image_to_world.py,sha256=F4rpSexO_2lSFOVQ5WjajhhmfS71x4_3HLDL7clEKzs,984
 borea_tools/ptfile_world_to_image.py,sha256=NkAmhppWW_boXIhKue5aoNCLnrhv8G2IwVqJJto-8MM,984
-borea_tools/spaceresection_opk.py,sha256=z8t8JmsVT_yxAC3y-6a7VlDnILnQHgpyfKT_H1OhWZI,1276
-ign_borea-0.1.5.dist-info/LICENSE,sha256=dYSQkCbiWEky0zxQDlv5bJoETo6HWl5bLK1YZ3EjaUc,1120
-ign_borea-0.1.5.dist-info/METADATA,sha256=9B-owvLEemlHjPBaR33jf5A7ZGnKXRrn3ou6BTuGc1s,17061
-ign_borea-0.1.5.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-ign_borea-0.1.5.dist-info/entry_points.txt,sha256=RDC7_y9WZW1Oae0JSHSem8k26jforKHSqdXaFsllxnw,579
-ign_borea-0.1.5.dist-info/top_level.txt,sha256=lJfyWpWFfy0625vF49vsPvf7TBTZa3CExzPW5Iormno,18
-ign_borea-0.1.5.dist-info/RECORD,,
+borea_tools/spaceresection_opk.py,sha256=xZeLZnSLFBP2BCKT_ere8r0mjvfIkr9GkU7HG3hWCUo,1240
+borea_tools/transform_proj_points.py,sha256=oFBLrV0xZKqmuNsGwUsnfN3ODnzXXOpbLCM-PggURbM,792
+ign_borea-0.2.1.dist-info/LICENSE,sha256=dYSQkCbiWEky0zxQDlv5bJoETo6HWl5bLK1YZ3EjaUc,1120
+ign_borea-0.2.1.dist-info/METADATA,sha256=kgup0xHOgTeYQNdX63pMfTAfV748Qr3qi5PkdINy-CI,17115
+ign_borea-0.2.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ign_borea-0.2.1.dist-info/entry_points.txt,sha256=b6glLVH7i9ZDczq9jixxTcm3eBtd-hhQk8CB6wMgK2c,655
+ign_borea-0.2.1.dist-info/top_level.txt,sha256=lJfyWpWFfy0625vF49vsPvf7TBTZa3CExzPW5Iormno,18
+ign_borea-0.2.1.dist-info/RECORD,,

{ign_borea-0.1.5.dist-info → ign_borea-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{ign_borea-0.1.5.dist-info → ign_borea-0.2.1.dist-info}/entry_points.txt

@@ -8,3 +8,4 @@ pt-world-to-image = borea_tools.pt_world_to_image:pt_world_to_image
 ptfile-image-to-world = borea_tools.ptfile_image_to_world:ptfile_image_to_world
 ptfile-world-to-image = borea_tools.ptfile_world_to_image:ptfile_world_to_image
 spaceresection-opk = borea_tools.spaceresection_opk:spaceresection_opk
+transform-proj-points = borea_tools.transform_proj_points:transform_proj_pt