ign-borea 0.1.5__py3-none-any.whl

borea/geodesy/proj_engine.py

@@ -0,0 +1,70 @@
+"""
+Module for manipulating a cartographic system.
+"""
+from typing import Union, List
+from dataclasses import dataclass
+import pyproj
+import numpy as np
+from borea.geodesy.transform_geodesy import TransformGeodesy
+from borea.utils.singleton.singleton import Singleton
+
+
+# pylint: disable=unpacking-non-sequence
+@dataclass
+class ProjEngine(TransformGeodesy, metaclass=Singleton):
+    """
+    This class provides functions for using a cartographic system.
+    """
+    epsg: int = None
+    geoid: list = None
+
+    def __post_init__(self) -> None:
+        if self.epsg:
+            self.crs = pyproj.CRS.from_epsg(self.epsg)
+            self.proj = pyproj.Proj(self.crs)
+            TransformGeodesy.__tf_init__(self, self.geoid, self.crs)
+
+    def set_epsg(self, epsg: int, geoid: list = 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".
+            geoid (list): List of geoid to use.
+        """
+        self.epsg = epsg
+        self.geoid = geoid
+        self.__post_init__()
+
+    def get_meridian_convergence(self, x_carto: Union[np.ndarray, List[float], float],
+                                 y_carto: Union[np.ndarray, List[float], float]) -> np.ndarray:
+        """
+        Compute meridian convergence.
+        Values are extracted from pyproj.
+
+        Args:
+            x_carto (np.array, List[float], float): x cartographic coordinates.
+            y_carto (np.array, List[float], float): y cartographic coordinates.
+
+        Returns:
+            np.array : Meridian convergence in degree.
+        """
+        (x_geog, y_geog) = self.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],
+                         y_carto: Union[np.ndarray, List[float], float]) -> np.ndarray:
+        """
+        Compute scale factor.
+        Values are extracted from pyproj.
+
+        Args:
+            x_carto (Union[np.array, List[float], float]): x cartographic coordinates.
+            y_carto (Union[np.array, List[float], float]): y cartographic coordinates.
+
+        Returns:
+            np.array: Scale factor and meridian convergence.
+        """
+        x_geog, y_geog = self.carto_to_geog(x_carto, y_carto)
+        return np.array(self.proj.get_factors(x_geog, y_geog).meridional_scale) - 1

borea/geodesy/projectionlist/search_proj.py

@@ -0,0 +1,60 @@
+"""
+Research data in ProjectionList.txt.
+"""
+import os
+
+
+PATH_FILE = os.path.join(os.path.dirname(__file__), "ProjectionList.txt")
+
+
+def convert_line_list(line: str) -> list:
+    """
+    Convert type of all element in list in str.
+
+    Args:
+        list_data(str): One line of file.
+
+    Returns:
+        list: List with str object.
+    """
+    return [x[1:-1] for x in line[1:-2].split(',')]
+
+
+def search_info(type_input: str, data_input: str, type_output: str) -> str:
+    """
+    Research data in ProjectionList.txt.
+    header: ["SD","BDORTHO","EPSG","GEOVIEW","MAPINFO","PROJ4","TA","TOPAERO","WKT"]
+
+    Args:
+        type_input (str): type of data input to refer.
+        data_input (str): data to refer.
+        type_output (str): type of data output to research.
+
+    Returns:
+        str: data output.
+    """
+    try:
+        with open(PATH_FILE, 'r', encoding="utf-8") as file_proj:
+            list_data = file_proj.readlines()
+            header = convert_line_list(list_data[0])
+            if type_input.upper() not in header and type_output.upper() not in header:
+                raise ValueError(f"{type_input} or {type_output} not in header: {header}")
+
+            id_input = header.index(type_input)
+            id_output = header.index(type_output)
+
+            for info_proj in list_data[1:]:
+                data = convert_line_list(info_proj)
+                if data[id_input] == "null" or data[id_output] == "null":
+                    continue
+                if data[id_input] == data_input:
+                    data_research = data[id_output]
+                    break
+
+        file_proj.close()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"The path {PATH_FILE} is incorrect !!!") from e
+
+    if data_research == "null":
+        return None
+    return data_research

borea/geodesy/transform_geodesy.py

@@ -0,0 +1,114 @@
+"""
+Module for class ProjEngine, transform geodesy
+"""
+from dataclasses import dataclass
+import pyproj
+import numpy as np
+
+
+# pylint: disable=unsubscriptable-object
+@dataclass
+class TransformGeodesy():
+    """
+    This class provides functions to tranform coordinate system.
+    Class parent of ProjEngine.
+    Implemented by ProjEngine.
+
+    Args:
+        geoid (list): List of geoid to use.
+        crs (pyproj): CRS pyproj of the worksite.
+    """
+    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.
+
+        Args:
+            geoid (list): List of geoid to use.
+        """
+        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
+
+    def tranform_height(self, coor: np.ndarray) -> float:
+        """
+        Converting z in altitude to z in height of point.
+
+        Args:
+            coor (np.array): [X, Y, Z] coordinate of the point.
+
+        Returns:
+            float: New height Z.
+        """
+        coor_geog = self.carto_to_geog(coor[0], coor[1], coor[2])
+        try:
+            coor_geog = self.geoid_to_geog(coor_geog[0],
+                                           coor_geog[1],
+                                           coor_geog[2])
+            new_z = self.geog_to_carto(coor_geog[0],
+                                       coor_geog[1],
+                                       coor_geog[2])[2]
+        except AttributeError as info:
+            raise ValueError("The geoid has not been entered, "
+                             "cannot transform z altitude to height.") from info
+
+        if new_z == np.inf:
+            raise ValueError("out geoid")
+        return new_z
+
+    def tranform_altitude(self, coor: np.ndarray) -> float:
+        """
+        Converting z in height to z in altitude of point.
+
+        Args:
+            coor (np.array): [X, Y, Z] coordinate of the point.
+
+        Returns:
+            float: New altitude Z.
+        """
+        coor_geog = self.carto_to_geog(coor[0], coor[1], coor[2])
+        try:
+            coor_geog = self.geog_to_geoid(coor_geog[0],
+                                           coor_geog[1],
+                                           coor_geog[2])
+            new_z = self.geog_to_carto(coor_geog[0],
+                                       coor_geog[1],
+                                       coor_geog[2])[2]
+        except AttributeError as info:
+            raise ValueError("The geoid has not been entered, "
+                             "cannot transform z height to altitude.") from info
+
+        if np.all(new_z == np.inf):
+            raise ValueError("out geoid")
+        return new_z

borea/process/p_add_data/p_add_shot.py

@@ -0,0 +1,63 @@
+"""
+Args of parser for adding one shot
+"""
+import argparse
+import numpy as np
+from borea.process.p_add_data.p_gen_param import args_general_param, process_args_gen_param
+from borea.process.p_add_data.p_unit_shot import args_input_shot
+from borea.worksite.worksite import Worksite
+
+
+def args_add_shot(parser: argparse) -> argparse:
+    """
+    Args for adding one shot.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-n', '--name_shot',
+                        type=str, default='Test',
+                        help='Name of the shot.')
+    parser.add_argument('-s', '--pos_shot',
+                        type=float, nargs=3,
+                        help='Position of the shot X Y Z.')
+    parser.add_argument('-t', '--unit_z_shot',
+                        type=str, choices=['altitude', 'height'],
+                        help='Unit of the z of the shot.')
+    parser.add_argument('-o', '--ori_shot',
+                        type=float, nargs=3,
+                        help='Orientation of the shot Omega Phi Kappa.')
+    parser = args_input_shot(parser)
+    parser = args_general_param(parser)
+    return parser
+
+
+def process_add_shot(args: argparse) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data)
+
+    Returns:
+        Worksite: data
+    """
+    work = Worksite("Calc_one_img")
+    work = process_args_gen_param(args, work)
+
+    work.add_shot(args.name_shot,
+                  np.array(args.pos_shot),
+                  np.array(args.ori_shot),
+                  work.cameras[list(work.cameras.keys())[0]].name_camera,
+                  args.unit_angle,
+                  args.linear_alteration,
+                  args.order_axe_input)
+
+    work.set_param_shot(args.approx_system)
+
+    work.type_z_shot = args.unit_z_shot
+
+    return work

borea/process/p_add_data/p_file_gcp2d.py

@@ -0,0 +1,55 @@
+"""
+Args of parser to read gcp 2D file.
+"""
+import argparse
+from borea.worksite.worksite import Worksite
+from borea.reader.reader_point import read_file_pt
+
+
+def args_gcp2d(parser: argparse) -> argparse:
+    """
+    Args to read gcp 2D file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-t', '--gcp2d',
+                        type=str, default=None,
+                        help='File path of ground control points in images.')
+    parser.add_argument('-k', '--head_gcp2d',
+                        type=str, default="PNXY",
+                        help='Header of the file gcp2d.'
+                        'e.g. PNXY'
+                        'S: to ignore the column'
+                        'P: name of point'
+                        'N: name of shot'
+                        'X: coordinate x (column) in the image'
+                        'Y: coordinate y (line) in the image')
+    return parser
+
+
+def process_gcp2d(args, work: Worksite) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+
+    Returns:
+        Worksite: data
+    """
+    # Reading ground point image
+    if args.gcp2d is not None:
+        read_file_pt(args.gcp2d, list(args.head_gcp2d.upper()), "gcp2d", work)
+        print("Connecting point reading done.")
+        count = 0
+        for k in work.gcp2d.values():
+            count += len(k)
+        print(f"Number of gcp 2D in image: {len(work.gcp2d)}")
+        print(f"Number of image with gcp 2D: {count}")
+
+    return work

borea/process/p_add_data/p_file_gcp3d.py

@@ -0,0 +1,53 @@
+"""
+Args of parser to read gcp 3D file.
+"""
+import argparse
+from borea.worksite.worksite import Worksite
+from borea.reader.reader_point import read_file_pt
+
+
+def args_gcp3d(parser: argparse) -> argparse:
+    """
+    Args to read gcp 3D file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-g', '--gcp3d',
+                        type=str, default=None,
+                        help='File path of ground control points in terrain.')
+    parser.add_argument('-l', '--head_gcp3d',
+                        type=str, default="PTXYZ",
+                        help='Header of the file gcp3d.'
+                        'e.g. PTXYZ'
+                        'S: to ignore the column'
+                        'P: name of point'
+                        'T: Type of gcp to control.'
+                        'X: coordinate x of the shot position'
+                        'Y: coordinate y of the shot position'
+                        'Z: coordinate z altitude of the shot position'
+                        'H: coordinate z height of the shot position')
+    return parser
+
+
+def process_gcp3d(args, work: Worksite) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+
+    Returns:
+        Worksite: data
+    """
+    # Reading GCP 3D
+    if args.gcp3d is not None:
+        read_file_pt(args.gcp3d, list(args.head_gcp3d.upper()), "gcp3d", work)
+        print("GCP reading done.")
+        print(f"Number of gcp: {len(work.gcp3d)}")
+
+    return work

borea/process/p_add_data/p_gen_param.py

@@ -0,0 +1,76 @@
+"""
+Args of parser for reading generals parameters
+"""
+import argparse
+import pyproj
+from borea.worksite.worksite import Worksite
+from borea.reader.reader_camera import read_camera
+
+
+def args_general_param(parser: argparse) -> argparse:
+    """
+    Args for adding general 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('-c', '--camera',
+                        type=str, nargs='*',
+                        help='Files paths of cameras (xml or txt).')
+    parser.add_argument('-m', '--dtm',
+                        type=str, default=None,
+                        help='DtM of the worksite.')
+    parser.add_argument('--fm', '--format_dtm',
+                        type=str, default=None,
+                        help='Format of Dtm "altitude" or "height".')
+    parser.add_argument('-x', '--approx_system',
+                        type=bool, default=False,
+                        help="To use an approximate system.")
+    return parser
+
+
+def process_args_gen_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.pathgeoid)
+        print(f"Projection set-up with EPSG:{args.epsg}.")
+    else:
+        print("There is no given projection.")
+
+    # Reading camera file
+    if args.camera is not None:
+        read_camera(args.camera, work)
+        print(f"Camera file reading done. {len(args.camera)} read")
+    else:
+        print("There is no given camera.")
+
+    # Add Dem
+    work.set_dtm(args.dtm, args.fm)
+    if args.dtm is not None:
+        print("Add dtm to the worksite done.")
+    else:
+        print("Not Dtm in the worksite.")
+
+    work.set_param_shot(args.approx_system)
+    return work

borea/process/p_add_data/p_pt2d.py

@@ -0,0 +1,48 @@
+"""
+Args of parser for world coordinate of image point
+"""
+import argparse
+import numpy as np
+from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
+from borea.worksite.worksite import Worksite
+
+
+def args_add_pt2d(parser: argparse) -> argparse:
+    """
+    Args for 2D point
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-p', '--point2d',
+                        type=float, nargs=2,
+                        help='Coordinate of the 2D point Column Line.')
+    parser.add_argument('-d', '--type_z_data',
+                        type=str, default=None, choices=['altitude', 'height', None],
+                        help='Unit of the z of the data in output.')
+
+    return parser
+
+
+def process_image_world(args: argparse, work: Worksite) -> None:
+    """
+    Processing args to calculate world coordinate of the point.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Worksite to work on.
+    """
+    work.set_type_z_data(args.type_z_data)
+
+    coor3d = ImageWorldShot(work.shots[args.name_shot],
+                            work.cameras[list(work.cameras.keys())[0]]
+                            ).image_to_world(np.array(args.point2d),
+                                             work.type_z_data,
+                                             work.type_z_shot)
+    print(f"World coordinate of the point 2D {args.point2d} is : {np.round(coor3d, 2)}")
+    print("Data summary:")
+    print(f"* position shot {work.shots[args.name_shot].pos_shot}")
+    print(f"* orientation shot {work.shots[args.name_shot].ori_shot}")

borea/process/p_add_data/p_pt3d.py

@@ -0,0 +1,48 @@
+"""
+Args of parser for image coordinate of ground point
+"""
+import argparse
+import numpy as np
+from borea.transform_world_image.transform_shot.world_image_shot import WorldImageShot
+from borea.worksite.worksite import Worksite
+
+
+def args_add_pt3d(parser: argparse) -> argparse:
+    """
+    Args for 3D point
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-p', '--point3d',
+                        type=float, nargs=3,
+                        help='Coordinate of the 3D point X Y Z.')
+    parser.add_argument('-d', '--type_z_data',
+                        type=str, default=None, choices=['altitude', 'height', None],
+                        help='Unit of the z of the data.')
+
+    return parser
+
+
+def process_world_image(args: argparse, work: Worksite) -> None:
+    """
+    Processing args to calculate image coordinate of the point.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Worksite to work on.
+    """
+    work.set_type_z_data(args.type_z_data)
+
+    coor2d = WorldImageShot(work.shots[args.name_shot],
+                            work.cameras[list(work.cameras.keys())[0]]
+                            ).world_to_image(np.array(args.point3d),
+                                             work.type_z_data,
+                                             work.type_z_shot)
+    print(f"Image coordinate of the point 3D {args.point3d} is : {np.round(coor2d, 2)}")
+    print("Data summary:")
+    print(f"* position shot {work.shots[args.name_shot].pos_shot}")
+    print(f"* orientation shot {work.shots[args.name_shot].ori_shot}")

borea/process/p_add_data/p_unit_shot.py

@@ -0,0 +1,48 @@
+"""
+Args of parser for unit of shot
+"""
+import argparse
+
+
+def args_input_shot(parser: argparse) -> argparse:
+    """
+    Args for reading opk file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-b', '--order_axe_input',
+                        type=str, default="opk",
+                        help="Order of rotation matrix axes.")
+    parser.add_argument('-u', '--unit_angle',
+                        type=str, default="degree", choices=['degree', 'radian'],
+                        help="Unit of the angle of shooting, 'degree' or 'radian'.")
+    parser.add_argument('-a', '--linear_alteration',
+                        type=bool, default=True,
+                        help="True if z shot corrected by linear alteration.")
+    return parser
+
+
+def args_output_shot(parser: argparse) -> argparse:
+    """
+    Args for reading opk file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    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',
+                        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',
+                        type=bool, default=None,
+                        help="True if z shot corrected by linear alteration.")
+    return parser

borea/process/p_add_data/p_write.py

@@ -0,0 +1,23 @@
+"""
+Args of parser to write file.
+"""
+import argparse
+
+
+def args_writer(parser: argparse) -> argparse:
+    """
+    Args to write file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-n', '--namereturn',
+                        type=str,
+                        help='Name of the new file.')
+    parser.add_argument('-w', '--pathreturn',
+                        type=str, default='./',
+                        help='Conversion path e.g. test/tmp/.')
+    return parser