ign-borea 0.1.5__py3-none-any.whl

borea/datastruct/camera.py

@@ -0,0 +1,25 @@
+"""
+Camera data class module.
+"""
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Camera:
+    """
+    Camera class definition.
+
+    Args:
+        name_camera (str): Name of the camera.
+        ppax (float): Center of distortion in x.
+        ppay (float): Center of distortion in y.
+        focal (float): Focal of the camera.
+        width (int): Width of the image in pixel.
+        height (int): Height of the image in pixel.
+    """
+    name_camera: str
+    ppax: float = field(default=None)
+    ppay: float = field(default=None)
+    focal: float = field(default=None)
+    width: int = field(default=None)
+    height: int = field(default=None)

borea/datastruct/dtm.py

@@ -0,0 +1,119 @@
+"""
+A module for manipulating a digital elevation model.
+"""
+from pathlib import Path, PureWindowsPath
+import numpy as np
+from osgeo import gdal
+from scipy import ndimage
+from borea.transform_world_image.transform_dtm.world_image_dtm import WorldImageDtm
+from borea.utils.singleton.singleton import Singleton
+gdal.UseExceptions()
+
+
+# pylint: disable-next=too-many-instance-attributes
+class Dtm(WorldImageDtm, metaclass=Singleton):
+    """
+    Represents a digital elevation model.
+
+    Args:
+        path_dtm (str): Path to the dtm file. If None Dtm.get() always returns  0.
+        order (int): The method of interpolation to perform.
+                    0 : nearest, 1 : slinear, 3 : cubic, 5 : quintic.
+        cval (int): Value to fill past edges of dtm.
+                    If None raise an error for any point outside the dtm.
+        keep_in_memory (bool): Store all data in memory.
+
+    .. note::
+        All gdal formats are supported. The file must contain georeferencing information.
+    """
+    def __init__(self):
+        self.path_dtm = None
+        self.type_dtm = None
+        self.order = 1
+        self.keep_in_memory = False
+        self.cval = np.nan
+        self.img = None
+        self.rb = None
+        self.nodata = None
+        self.dtm_array = None
+        WorldImageDtm.__init__(self, None)
+
+    def set_dtm(self, path_dtm: str, type_dtm: str) -> None:
+        """
+        Set the dtm path for reading dtm.
+
+        Args:
+            path_dtm (str): Path to the dtm file.
+            type (str): Type of dtm "a" altitude, "h" height.
+        """
+        if path_dtm:
+            gdal.AllRegister()
+            self.type_dtm = type_dtm
+            self.path_dtm = Path(PureWindowsPath(path_dtm))
+            self.img = gdal.Open(self.path_dtm.as_posix())
+            self.rb = self.img.GetRasterBand(1)
+            self.nodata = self.rb.GetNoDataValue()
+            if self.keep_in_memory:
+                self.dtm_array = self.rb.ReadAsArray()
+            WorldImageDtm.__init__(self, self.img.GetGeoTransform())
+        else:
+            self.path_dtm = path_dtm
+
+    def set_order(self, order: int) -> None:
+        """
+        The method of interpolation to perform.
+        0:nearest 1:bilinear 3:cubic 5:quintic.
+
+        Args:
+            order (int): The method of interpolation to perform.
+        """
+        self.order = order
+
+    def set_cval(self, cval: int) -> None:
+        """
+        Value to fill past edges of dtm or nodata.
+        If None raise an error for any point outside the dtm or Nodata.
+
+        Args
+            cval (int): Value to fill past edges of dtm or nodata.
+        """
+        self.cval = cval if cval else np.nan
+
+    def set_keep_memory(self, keep_memory: bool) -> None:
+        """
+        Store all image in memory.
+
+        Args:
+            keep_in_memory (bool): Store all image in memory.
+        """
+        self.keep_in_memory = keep_memory
+
+    def get_z_world(self, coor_2d: np.ndarray) -> np.ndarray:
+        """
+        Extract value in the Dtm.
+
+        Args:
+            coor_2d (np.array): World coordinate 2D [X, Y].
+
+        Returns:
+            np.array: z value.
+        """
+        if self.path_dtm is None:
+            return np.zeros_like(coor_2d[0])
+        col, line = self.world_to_image(coor_2d)
+        if not self.keep_in_memory:
+            z = []
+            if isinstance(col, float):
+                col, line = [col], [line]
+            for colt, linet in zip(col, line):
+                try:
+                    z += [self.rb.ReadAsArray(colt, linet, 1, 1, resample_alg=self.order)]
+                except RuntimeError:
+                    z += [self.cval]
+        else:
+            z = ndimage.map_coordinates(self.dtm_array, np.vstack([line, col]),
+                                        order=self.order, mode="constant", cval=self.cval)
+        if np.any(np.isnan(z)):
+            raise IndexError(f"Out dtm {coor_2d[0]} {coor_2d[1]}")
+
+        return np.round(np.array(z, dtype=float), 3)

borea/datastruct/gcp.py

@@ -0,0 +1,22 @@
+"""
+Ground Control Point (GCP) class.
+"""
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class GCP:
+    """
+    Ground Control Point class.
+
+    Args:
+        name_gcp (str): Name of the gcp.
+        code (str): IGN code to differentiate between support points (1, 2, 3)
+                    and control points (11, 12, 13)
+                    1 means precision in Z, 2 in X and Y and 3 in X, Y, Z.
+        coor (numpy.array): Array of ground coordinate [X, Y, Z].
+    """
+    name_gcp: str
+    code: str
+    coor: np.ndarray

borea/datastruct/shot.py

@@ -0,0 +1,222 @@
+"""
+Acquisition data class module.
+"""
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+from borea.geodesy.proj_engine import ProjEngine
+from borea.geodesy.approx_euclidean_proj import ApproxEuclideanProj
+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
+class Shot:
+    """
+    Shot class definition.
+
+    Args:
+        name_shot (str): Name of the shot.
+        pos_shot (numpy.array): Array of coordinate position [X, Y, Z].
+        ori_shot (numpy.array): Array of orientation of the shot [Omega, Phi, Kappa] in degree.
+        name_cam (str): Name of the camera.
+        unit_angle (str): Unit of angle 'degrees', 'radian'.
+        linear_alteration (bool): True if z shot is correct of linear alteration.
+        order_axe (str): Order of rotation matrix axes.
+    """
+    def __init__(self, name_shot: str, pos_shot: np.ndarray,
+                 ori_shot: np.ndarray, name_cam: str,
+                 unit_angle: str, linear_alteration: bool,
+                 order_axe: str) -> None:
+        self.name_shot = name_shot
+        self.pos_shot = pos_shot
+        self.pos_shot_eucli = None
+        self.linear_alteration = linear_alteration
+        self.ori_shot = ori_shot
+        self.unit_angle = unit_angle
+        self.name_cam = name_cam
+        self.order_axe = order_axe
+        self.z_nadir = None
+        self.co_points = {}
+        self.gcp2d = {}
+        self.gcp3d = {}
+        self.mat_rot = self.set_rot_shot()
+        self.mat_rot_eucli = None
+        self.projeucli = None
+        self.approxeucli = False
+        self.f_sys = lambda x_shot, y_shot, z_shot: (x_shot, y_shot, z_shot)
+        self.f_sys_inv = lambda x_shot, y_shot, z_shot: (x_shot, y_shot, z_shot)
+
+    @classmethod
+    def from_param_euclidean(cls, name_shot: str, pos_eucli: np.ndarray,
+                             mat_ori_eucli: np.ndarray, name_cam: str,
+                             unit_angle: str, linear_alteration: bool,
+                             order_axe: str, approx: bool) -> None:
+        """
+        Construction of a shot object using the Euclidean position.
+
+        Args:
+            name_shot (str): Name of the shot.
+            pos_eucli (np.array): Euclidean position of the shot.
+            mat_ori_eucli (np.array): Euclidean rotation matrix of the shot.
+            name_cam (str): Name of the camera.
+            unit_angle (str): Unit of angle 'degrees', 'radian'.
+            linear_alteration (bool): True if z shot is correct of linear alteration.
+            order_axe (str): Order of rotation matrix axes.
+            approx (bool): True if you want to use approx euclidean system.
+
+        Returns:
+            Shot: The shot.
+        """
+        shot = cls(name_shot, np.array([0, 0, 0]), np.array([0, 0, 0]),
+                   name_cam, unit_angle, linear_alteration, order_axe)
+        shot.pos_shot_eucli = pos_eucli
+        shot.approxeucli = approx
+        if approx:
+            shot.projeucli = ApproxEuclideanProj(pos_eucli[0], pos_eucli[1])
+        else:
+            shot.projeucli = LocalEuclideanProj(pos_eucli[0], pos_eucli[1])
+        unitori = shot.unit_angle == "degree"
+        shot.pos_shot = shot.projeucli.eucli_to_world(pos_eucli)
+        shot.co_points = {}
+        shot.gcp3d = {}
+        shot.gcp2d = {}
+        shot.mat_rot = shot.projeucli.mat_eucli_to_mat(shot.pos_shot[0], shot.pos_shot[1],
+                                                       mat_ori_eucli)
+        shot.mat_rot_eucli = mat_ori_eucli
+        order_xyz = check_order_axe(order_axe)
+        shot.ori_shot = -(R.from_euler("x", np.pi) *
+                          R.from_matrix(shot.mat_rot)).as_euler(order_xyz, degrees=unitori)
+
+        shot.f_sys = lambda x_shot, y_shot, z_shot: (x_shot, y_shot, z_shot)
+        shot.f_sys_inv = lambda x_shot, y_shot, z_shot: (x_shot, y_shot, z_shot)
+
+        return shot
+
+    def set_rot_shot(self) -> np.ndarray:
+        """
+        Build the rotation matrix with omega phi kappa.
+
+        Returns:
+            np.array: The rotation matrix.
+        """
+        order_xyz = check_order_axe(self.order_axe)
+        rot = R.from_euler(order_xyz, -np.array(self.ori_shot), degrees=self.unit_angle == "degree")
+        rot = R.from_euler("x", np.pi) * rot
+        return rot.as_matrix()
+
+    def set_param_eucli_shot(self, approx: bool) -> None:
+        """
+        Setting up Euclidean parameters projeucli, pos_shot_eucli, mat_rot_eucli.
+
+        Args:
+            approx (bool): True if you want to use approx euclidean system.
+        """
+        if approx:
+            self.projeucli = ApproxEuclideanProj(self.pos_shot[0], self.pos_shot[1])
+        else:
+            self.projeucli = LocalEuclideanProj(self.pos_shot[0], self.pos_shot[1])
+
+        self.mat_rot_eucli = self.projeucli.mat_to_mat_eucli(self.pos_shot[0],
+                                                             self.pos_shot[1],
+                                                             self.mat_rot)
+        self.approxeucli = approx
+        self.pos_shot_eucli = self.projeucli.world_to_eucli(self.pos_shot)
+
+    def set_z_nadir(self, z_nadir: float) -> None:
+        """
+        Give z nadir to the shot.
+
+        Args:
+            z_nadir (flaot): z_nadir of the shot.
+        """
+        self.z_nadir = z_nadir
+
+    def set_unit_angle(self, unit_angle: str) -> None:
+        """
+        Allows you to change the orientation angle unit.
+
+        Args:
+            unit_angle (str): Unit angle.
+        """
+        if unit_angle != self.unit_angle:
+            self.unit_angle = unit_angle
+            if unit_angle == "radian":
+                self.ori_shot = self.ori_shot*np.pi/180
+            else:
+                self.ori_shot = self.ori_shot*180/np.pi
+
+    def set_type_z(self, type_z: str) -> None:
+        """
+        Allows you to change the type of z.
+
+        Args:
+            type_z (str): z type height or altitude.
+        """
+        if type_z == "height":
+            self.pos_shot[2] = ProjEngine().tranform_height(self.pos_shot)
+        else:
+            self.pos_shot[2] = ProjEngine().tranform_altitude(self.pos_shot)
+
+    def set_linear_alteration(self, linear_alteration: bool) -> None:
+        """
+        Allows you to correct or de-correct the linear alteration.
+
+        Args:
+            linear_alteration (bool): Linear alteration boolean.
+        """
+        if linear_alteration != self.linear_alteration:
+            self.linear_alteration = linear_alteration
+            if linear_alteration:
+                self.pos_shot[2] = self.get_z_add_scale_factor()
+            else:
+                self.pos_shot[2] = self.get_z_remove_scale_factor()
+
+    def set_order_axe(self, order_axe: str) -> None:
+        """
+        Allows to change order of axe for the matrice and angle.
+
+        Args:
+            order_axe (str): New order axe.
+        """
+        if order_axe != self.order_axe:
+            self.order_axe = order_axe
+            order_xyz = check_order_axe(self.order_axe)
+            unitori = self.unit_angle == "degree"
+            self.ori_shot = -(R.from_euler("x", np.pi) *
+                              R.from_matrix(self.mat_rot)).as_euler(order_xyz, degrees=unitori)
+
+    def get_z_remove_scale_factor(self) -> float:
+        """
+        Return Z after removing the scale factor. The Z of the object is NOT modified.
+
+        Returns:
+            float: z without linear alteration.
+        """
+        if self.z_nadir:
+            scale_factor = ProjEngine().get_scale_factor(self.pos_shot[0],
+                                                         self.pos_shot[1])
+            new_z = (self.pos_shot[2] + scale_factor * self.z_nadir) / (1 + scale_factor)
+        else:
+            raise ValueError(f"No removing linear alteration of the z shot {self.name_shot}, "
+                             "because no dtm or no set z_nadir of shot. For setting z_nadir "
+                             "of shots make dtm or add work.set_z_nadir_shot()")
+
+        return new_z
+
+    def get_z_add_scale_factor(self) -> float:
+        """
+        Return Z after adding the scale factor. The Z of the object is NOT modified.
+
+        Returns:
+            float: z with linear alteration.
+        """
+        if self.z_nadir:
+            scale_factor = ProjEngine().get_scale_factor(self.pos_shot[0],
+                                                         self.pos_shot[1])
+            new_z = self.pos_shot[2] + scale_factor * (self.pos_shot[2] - self.z_nadir)
+        else:
+            raise ValueError(f"No adding linear alteration of the z shot {self.name_shot}, "
+                             "because no dtm or no set z_nadir of shot. For setting z_nadir "
+                             "of shots make dtm or add work.set_z_nadir_shot()")
+
+        return new_z

borea/datastruct/workdata.py

@@ -0,0 +1,220 @@
+"""
+Workdata data class module.
+"""
+import numpy as np
+from pyproj import CRS, exceptions
+from borea.datastruct.shot import Shot
+from borea.datastruct.camera import Camera
+from borea.datastruct.gcp import GCP
+from borea.geodesy.proj_engine import ProjEngine
+from borea.datastruct.dtm import Dtm
+
+
+# pylint: disable-next=too-many-instance-attributes
+class Workdata:
+    """
+    Workdata class.
+    """
+    def __init__(self, name: str) -> None:
+        """
+        Class definition of Workdata.
+
+        Args:
+            name (str): Name of the worksite.
+        """
+        self.name = name
+        self.shots = {}
+        self.cameras = {}
+        self.co_points = {}
+        self.gcp2d = {}
+        self.gcp3d = {}
+        self.co_pts_world = {}
+        self.gcp2d_in_world = {}
+        self.type_z_data = None
+        self.type_z_shot = None
+        self.approxeucli = False
+
+    # pylint: disable-next=too-many-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,
+                 order_axe: str) -> None:
+        """
+        Add Shot to the attribut Shots.
+
+        Args:
+            name_shot (str): Name of the shot.
+            pos_shot (np.array): Array of coordinate position [X, Y, Z].
+            ori_shot (np.array): Array of orientation of the shot [Omega, Phi, Kappa].
+            name_cam (str): Name of the camera.
+            unit_angle (str): Unit of angle 'degrees', 'radian'.
+            linear_alteration (bool): True if z shot is correct of linear alteration.
+            order_axe (str): Order of rotation matrix axes,
+        """
+        self.shots[name_shot] = Shot(name_shot=name_shot,
+                                     pos_shot=pos_shot,
+                                     ori_shot=ori_shot,
+                                     name_cam=name_cam,
+                                     unit_angle=unit_angle,
+                                     linear_alteration=linear_alteration,
+                                     order_axe=order_axe)
+
+    def set_proj(self, epsg: int, path_geoid: list = None) -> None:
+        """
+        Setup a projection system to the worksite.
+
+        Args:
+            epsg (int): Code epsg of the porjection ex: 2154.
+            path_geoid (str): List of GeoTIFF which represents the geoid in grid form.
+        """
+        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
+    def add_camera(self, name_camera: str, ppax: float, ppay: float,
+                   focal: float, width: int, height: int) -> None:
+        """
+        Add data camera in the Worksite.
+
+        Args:
+            name_camera (str): Name of the camera.
+            ppax (float): Center of distortion in x.
+            ppay (float): Center of distortion in y.
+            focal (float): Focal of the camera.
+            width (int): Width of the image camera.
+            height (int): Height of the image camera.
+        """
+        self.cameras[name_camera] = Camera(name_camera=name_camera,
+                                           ppax=ppax,
+                                           ppay=ppay,
+                                           focal=focal,
+                                           width=width,
+                                           height=height)
+
+    def add_co_point(self, name_point: str, name_shot: str, coor2d: np.ndarray) -> None:
+        """
+        Add linking point between acquisition in two part.
+        One in self.co_points a dict with name_point the key and list of acquisition the result.
+        And One in self.shot[name_shot].co_points a dict whit
+        name_point the key and list of coordinate x (column) y (line) the result in list.
+
+        Agrs:
+            name_point (str): Name of the connecting point.
+            name_shot (str): Name of the acquisition.
+            coor2d (array): Pixel position in the shot [x, y] = [column, line]
+        """
+        if name_shot not in self.shots:
+            raise ValueError(f"The shot {name_shot} doesn't exist in list of shots.")
+
+        if name_point not in self.co_points:
+            self.co_points[name_point] = []
+
+        if name_point not in self.shots[name_shot].co_points:
+            self.shots[name_shot].co_points[name_point] = coor2d
+        else:
+            print("\n :--------------------------:")
+            print("Warning : connecting point duplicate.")
+            print(f"The point {name_point} already exists in the shot {name_shot}.")
+            print("Keep first point with coordinates " +
+                  f"{self.shots[name_shot].co_points[name_point]}.")
+            print(":--------------------------:")
+
+        self.co_points[name_point].append(name_shot)
+
+    def add_gcp2d(self, name_point: str, name_shot: str, coor2d: np.ndarray) -> None:
+        """
+        Add linking point between acquisition in two part.
+        One in self.gcp2d a dict with name_point the key
+        and list of acquisition the result.
+        And One in self.shot[name_shot].gcp2d a dict whit
+        name_point the key and list of coordinate x (column) y (line) the result in list.
+
+        Agrs:
+            name_point (str): Name of the connecting point.
+            name_shot (str): Name of the acquisition.
+            coor2d (array): Pixel position in the shot [x, y] = [column, line]
+        """
+        try:
+            self.shots[name_shot]
+        except KeyError as e_info:
+            raise ValueError(f"The shot {name_shot} doesn't exist in list of shots.") from e_info
+
+        if name_point not in self.gcp2d:
+            self.gcp2d[name_point] = []
+
+        if name_point not in self.shots[name_shot].gcp2d:
+            self.shots[name_shot].gcp2d[name_point] = coor2d
+        else:
+            print("\n :--------------------------:")
+            print("Warning : connecting point duplicate.")
+            print(f"The point {name_point} already exists in the shot {name_shot}.")
+            print("Keep first point with coordinates " +
+                  f"{self.shots[name_shot].gcp2d[name_point]}.")
+            print(":--------------------------:")
+
+        self.gcp2d[name_point].append(name_shot)
+
+    def add_gcp3d(self, name_gcp: str, code_gcp: str, coor_gcp: np.ndarray) -> None:
+        """
+        Add GCP in the Worksite.
+
+        Args:
+            name_gcp (str): Name of the gcp.
+            code_gcp (str): IGN code to differentiate between support points (1, 2, 3)
+                            and control points (11, 12, 13).
+                            1 means precision in Z, 2 in X and Y and 3 in X, Y, Z.
+            coor_gcp (numpy.array): Array of ground coordinate [X, Y, Z].
+        """
+        self.gcp3d[name_gcp] = GCP(name_gcp, code_gcp, coor_gcp)
+
+    def set_dtm(self, path_dtm: str, type_dtm: str) -> None:
+        """
+        Set class DtM to the worksite.
+
+        Args:
+            path_dtm (str): Path to the dtm.
+            type (str): Type of the dtm "altitude" or "height".
+        """
+        if path_dtm:
+            if type_dtm not in ["altitude", "height"]:
+                raise ValueError(f"The dtm's type {type_dtm} isn't correct"
+                                 " ('altitude' or 'height')")
+
+            Dtm.clear()
+            Dtm().set_dtm(path_dtm, type_dtm)
+
+    def set_approx_eucli_proj(self, approx: bool) -> None:
+        """
+        Setup approxeucli in worksite.
+
+        Args:
+            apprx (bool): True if there are not projengine.
+        """
+        self.approxeucli = approx
+
+    def set_type_z_shot(self, type_z_shot: str) -> None:
+        """
+        Setup type_z_shot in worksite.
+
+        Args:
+            type_z_shot (str): altitude or height.
+        """
+        self.type_z_shot = type_z_shot
+
+    def set_type_z_data(self, type_z_data: str) -> None:
+        """
+        Setup type_z_data with one condition if is None.
+
+        Args:
+            type_z_data (str): altitude or height.
+        """
+        if type_z_data:
+            self.type_z_data = type_z_data
+        else:
+            self.type_z_data = self.type_z_shot