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

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/manage_reader.py

@@ -2,7 +2,7 @@
 Photogrammetry site file reader module.
 """
 import importlib
-from pathlib import Path, PureWindowsPath
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 
 
@@ -19,7 +19,7 @@ def reader_orientation(file: str, args: dict) -> Worksite:
     """
     # Attention multiple file management orientation
     # Attention management of files with the same extension but different formats
-    file = Path(PureWindowsPath(file))
+    file = check_path(file)
     name_work = file.stem
     ext = file.suffix[1:]
 

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_camera.py

@@ -1,8 +1,9 @@
 """
 Script to read camera file txt or xml.
 """
-from pathlib import Path, PureWindowsPath
+from pathlib import Path
 from borea.datastruct.camera import Camera
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 
 
@@ -15,7 +16,7 @@ def read_camera(files: list, work: Worksite) -> None:
         work (Worksite): Worksite which needs camera data.
     """
     for file in files:
-        camera_txt(Path(PureWindowsPath(file)), work)
+        camera_txt(check_path(file), work)
 
 
 def camera_txt(file: Path, work: Worksite) -> None:

borea/reader/reader_point.py

@@ -2,9 +2,9 @@
 Script to read point (connecting point, gcp2d gcp3d) format
 .txt/.mes/.app with data arranged in columns.
 """
-from pathlib import Path, PureWindowsPath
 import pandas as pd
 import numpy as np
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 from borea.utils.check.check_args_reader_pt import check_header_file
 
@@ -26,7 +26,7 @@ def read_file_pt(path: str, header: list, type_point: str, work: Worksite) -> No
     work.type_z_data = type_z
 
     try:
-        with open(Path(PureWindowsPath(path)), 'r', encoding="utf-8") as file_pts:
+        with open(check_path(path), 'r', encoding="utf-8") as file_pts:
             for pt in file_pts.readlines():
                 if pt != '\n' and pt[0] != '#':
                     info = pt.split()
@@ -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,18 +63,18 @@ 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 = []
     coor = []
     try:
-        with open(Path(PureWindowsPath(path)), 'r', encoding="utf-8") as file_pts:
+        with open(check_path(path), 'r', encoding="utf-8") as file_pts:
             for pt in file_pts.readlines():
                 if pt != '\n' and pt[0] != '#':
                     info = pt.split()
@@ -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/stat/statistics.py

@@ -3,8 +3,8 @@ Module for statistics
 """
 import os
 import io
-from pathlib import Path, PureWindowsPath
 import numpy as np
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 
 
@@ -22,7 +22,7 @@ class Stat:
             type_point (list): List of type point on which we make the stats.
         """
         self.work = work
-        self.pathoutput = Path(PureWindowsPath(pathoutput))
+        self.pathoutput = check_path(pathoutput)
 
         if type_point is None:
             self.type_point = []

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/transform_world_image/transform_worksite/space_resection.py

@@ -13,6 +13,7 @@ from borea.transform_world_image.transform_shot.image_world_shot import ImageWor
 # pylint: disable-next=line-too-long
 from borea.transform_world_image.transform_worksite.image_world_intersection import WorldIntersection  # noqa: E501
 from borea.utils.miscellaneous.param_bundle import set_param_bundle_diff
+from borea.utils.solver.solver import npsolve
 
 
 class SpaceResection:
@@ -240,8 +241,7 @@ class SpaceResection:
 
         # Creation of A with mat_obs_axia
         # Calculate dx = (A.T @ A)**-1 @ A.T @ B
-        return np.squeeze(np.linalg.lstsq(self.mat_obs_axia(pt_eucli, shot_adjust),
-                                          v_res, rcond=None)[0])
+        return np.squeeze(npsolve(self.mat_obs_axia(pt_eucli, shot_adjust), v_res))
 
     def mat_obs_axia(self, pt_eucli: np.ndarray, imc_adjust: Shot) -> np.ndarray:
         """

borea/utils/check/check_path.py

@@ -0,0 +1,26 @@
+"""
+Script to check path of data.
+"""
+from pathlib import Path, PureWindowsPath, PurePosixPath
+
+
+def check_path(file: str) -> Path:
+    """
+    Check path of data if Posix of Windows path.
+
+    Args:
+        file (str): The path of data.
+
+    Returns:
+        Path: The good path.
+    """
+    file = Path(file)
+    name = file.stem
+
+    if "/" in name:
+        return Path(PurePosixPath(file))
+
+    if "\\" in name:
+        return Path(PureWindowsPath(file))
+
+    return file

borea/utils/solver/solver.py

@@ -0,0 +1,18 @@
+"""
+Least square solver used by Borea
+"""
+import numpy as np
+
+
+def npsolve(mat_a: np.ndarray, mat_b: np.ndarray) -> np.ndarray:
+    """
+    Solver used by Borea to resolve Ax = B
+
+    Args:
+        mat_a (np.ndarray): Matrix A
+        mat_b (np.ndarray): Matrix B
+
+    Returns:
+        np.ndarray: the result x
+    """
+    return np.linalg.lstsq(mat_a, mat_b, rcond=None)[0]

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

@@ -2,7 +2,7 @@
 Photogrammetry worksite to writing in rpc.
 """
 import os
-from pathlib import Path, PureWindowsPath
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 from borea.geodesy.proj_engine import ProjEngine
 from borea.format.conl import Conl
@@ -20,10 +20,17 @@ 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]
-        path_conical = os.path.join(Path(PureWindowsPath(folder_con)), f"{name_shot}.CON")
+        path_conical = os.path.join(check_path(folder_con), f"{name_shot}.CON")
 
         Conl(shot, cam, geoview_proj).save_conl(path_conical)

borea/writer/writer_df_to_txt.py

@@ -2,8 +2,8 @@
 Photogrammetry worksite to writing dataframe to txt.
 """
 import os
-from pathlib import Path, PureWindowsPath
 import pandas as pd
+from borea.utils.check.check_path import check_path
 
 
 def write_df_to_txt(name: str, pathreturn: str, df: pd.DataFrame) -> None:
@@ -15,7 +15,7 @@ def write_df_to_txt(name: str, pathreturn: str, df: pd.DataFrame) -> None:
         pathreturn (str): Path to save the file.
         df (pd.DataFrame): DataFrame to save.
     """
-    path_txt = os.path.join(Path(PureWindowsPath(pathreturn)), f"{name}.txt")
+    path_txt = os.path.join(check_path(pathreturn), f"{name}.txt")
 
     name_column = list(df.columns)
 

borea/writer/writer_opk.py

@@ -2,8 +2,8 @@
 Photogrammetry worksite to writing in opk.
 """
 import os
-from pathlib import Path, PureWindowsPath
 import numpy as np
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 from borea.utils.check.check_args_opk import check_header_file
 
@@ -24,7 +24,7 @@ def write(name_opk: str, path_opk: str, args: dict, work: Worksite) -> None:
                      linear alteration.
         work (Worksite): The site to be recorded.
     """
-    path_opk = os.path.join(Path(PureWindowsPath(path_opk)), f"{name_opk}.opk")
+    path_opk = os.path.join(check_path(path_opk), f"{name_opk}.opk")
 
     if args["header"]:
         header, type_z = check_header_file(args["header"])
@@ -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

@@ -2,8 +2,8 @@
 Photogrammetry worksite to writing in rpc.
 """
 import os
-from pathlib import Path, PureWindowsPath
 from borea.format.rpc import Rpc
+from borea.utils.check.check_path import check_path
 from borea.worksite.worksite import Worksite
 from borea.datastruct.dtm import Dtm
 
@@ -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]
@@ -50,6 +53,6 @@ def write(name: str, folder_rpc: str, param_rpc: dict, work: Worksite) -> None:
         for idx, val in enumerate(rpc.param_rpc["SAMP_DEN_COEFF"]):
             list_txt_rpc += [f"SAMP_DEN_COEFF_{idx + 1}: {val}"]
 
-        path_rpc = os.path.join(Path(PureWindowsPath(folder_rpc)),
+        path_rpc = os.path.join(check_path(folder_rpc),
                                 f"{name_shot}_RPC.TXT")
-        Path(path_rpc).write_text("\n".join(list_txt_rpc), encoding="UTF-8")
+        check_path(path_rpc).write_text("\n".join(list_txt_rpc), encoding="UTF-8")

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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ign-borea
-Version: 0.1.5
+Version: 0.2.2
 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