ign-borea 0.1.5__py3-none-any.whl

borea/format/conl.py

@@ -0,0 +1,143 @@
+"""
+Class to write shot in conical IGN format
+"""
+from datetime import datetime
+from pathlib import Path
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+
+import numpy as np
+from borea.datastruct.camera import Camera
+from borea.datastruct.shot import Shot
+from borea.utils.xml.xml import format_xml, indent, add_elem
+
+B_TIME = ["year", "month", "day", "hour", "minute", "second", "time_system"]
+B_PT3D = ["x", "y", "z"]
+B_ORI = ["easting", "northing", "altitude"]
+B_TCAM = ["width", "height"]
+B_CAM = ["c", "l", "focale"]
+
+
+@dataclass
+class Conl:
+    """
+    Class for light conical shot.
+    File reading by software Geoview IGN on MacOs.
+
+    Args:
+        shot (Shot): Shot to convert in conical file.
+        cam (Camera): Camera of the shot.
+        proj (str): Projection of the shot for GEOVIEW.
+    """
+    shot: Shot
+    cam: Camera
+    proj: str
+
+    def save_conl(self, path_conical: Path, linalt: bool = True) -> 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",
+                      {'date': date_now.strftime("%Y-%m-%d"),
+                       "time": date_now.strftime("%H h %M min %S sec")})
+        ET.SubElement(ori, "version").text = format_xml("1.0")
+
+        auxiliary_data = ET.SubElement(ori, "auxiliarydata")
+        ET.SubElement(auxiliary_data, "image_name").text = format_xml(self.shot.name_shot)
+
+        image_date = ET.SubElement(auxiliary_data, "image_date")
+        add_elem(image_date, B_TIME, [0, 0, 0, 0, 0, 0, None])
+
+        ET.SubElement(auxiliary_data, "samples")
+
+        self.set_geometry_xml(ori)
+
+        tree = ET.ElementTree(ori)
+        indent(ori)
+        tree.write(path_conical, encoding='utf-8', xml_declaration=True)
+
+    def set_geometry_xml(self, ori: ET) -> None:
+        """
+        Setup balise geometry of xml.
+
+        Args:
+            ori (ET): The xml.
+        """
+        pos_shot = np.round(np.copy(self.shot.pos_shot), 5)
+
+        geometry = ET.SubElement(ori, "geometry", {'type': "physique"})
+
+        extrinseque = ET.SubElement(geometry, "extrinseque")
+
+        systeme = ET.SubElement(extrinseque, "systeme")
+
+        euclidien = ET.SubElement(systeme, "euclidien", {'type': "MATISRTL"})
+        add_elem(euclidien, B_PT3D[:2], pos_shot[:2])
+
+        ET.SubElement(systeme, "geodesique").text = format_xml(self.proj).upper()
+
+        ET.SubElement(extrinseque, "grid_alti").text = format_xml("UNKNOWN")
+
+        sommet = ET.SubElement(extrinseque, "sommet")
+        add_elem(sommet, B_ORI, [0, 0, pos_shot[2]])
+
+        rotation = ET.SubElement(extrinseque, "rotation")
+        ET.SubElement(rotation, "Image2Ground").text = format_xml('false')
+
+        mat3d = ET.SubElement(rotation, "mat3d")
+
+        l1_pt3d = ET.SubElement(ET.SubElement(mat3d, "l1"), "pt3d")
+        add_elem(l1_pt3d, B_PT3D, [self.shot.mat_rot[0][0],
+                                   self.shot.mat_rot[0][1],
+                                   self.shot.mat_rot[0][2]], ".16f")
+
+        l2_pt3d = ET.SubElement(ET.SubElement(mat3d, "l2"), "pt3d")
+        add_elem(l2_pt3d, B_PT3D, [self.shot.mat_rot[1][0],
+                                   self.shot.mat_rot[1][1],
+                                   self.shot.mat_rot[1][2]], ".16f")
+
+        l3_pt3d = ET.SubElement(ET.SubElement(mat3d, "l3"), "pt3d")
+        add_elem(l3_pt3d, B_PT3D, [self.shot.mat_rot[2][0],
+                                   self.shot.mat_rot[2][1],
+                                   self.shot.mat_rot[2][2]], ".16f")
+
+        self.set_camera_xml(geometry)
+
+    def set_camera_xml(self, geometry: ET) -> None:
+        """
+        Setup balise camera of xml.
+
+        Args:
+            geometry (ET): The xml.
+        """
+        intrinseque = ET.SubElement(geometry, "intrinseque")
+
+        sensor = ET.SubElement(intrinseque, "sensor")
+        ET.SubElement(sensor, "name").text = self.cam.name_camera
+
+        calibration_date = ET.SubElement(sensor, "calibration_date")
+        add_elem(calibration_date, B_TIME, [0, 0, 0, 0, 0, 0, None])
+
+        ET.SubElement(sensor, "serial_number").text = format_xml("UNKNOWN")
+
+        image_size = ET.SubElement(sensor, "image_size")
+        add_elem(image_size, B_TCAM, [self.cam.width, self.cam.height])
+
+        sensor_size = ET.SubElement(sensor, "sensor_size")
+        add_elem(sensor_size, B_TCAM, [self.cam.width, self.cam.height])
+
+        ppa = ET.SubElement(sensor, "ppa")
+        add_elem(ppa, B_CAM, [int(self.cam.ppax), int(self.cam.ppay), int(self.cam.focal)])
+
+        ET.SubElement(sensor, "pixel_size").text = str(0.000004)

borea/format/rpc.py

@@ -0,0 +1,244 @@
+"""
+Class module for Rpc
+"""
+import numpy as np
+from borea.datastruct.shot import Shot
+from borea.datastruct.camera import Camera
+from borea.geodesy.proj_engine import ProjEngine
+from borea.datastruct.dtm import Dtm
+from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
+from borea.transform_world_image.transform_shot.world_image_shot import WorldImageShot
+from borea.utils.miscellaneous.miscellaneous import normalize
+
+
+class Rpc:
+    """
+    A class for computing RPC geometries.
+
+    .. note::
+        A RPC is always describing a transformation from
+        geographical coordinates to images coordinates.
+    """
+    def __init__(self) -> None:
+        self.param_rpc = {}
+        self.fact_rpc = None
+
+    @classmethod
+    def from_shot(cls, shot: Shot, cam: Camera, param_rpc: dict, unit_data: dict) -> None:
+        """
+        Calculate RPC of the shot.
+
+        Args:
+            shot (Shot): Shot to calculate rpc.
+            cam (Camera): Camera of the shot.
+            param_rpc (dict): Dictionary of parameters for rpc calculation.
+            key;
+            "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.
+            unit_data (dict): Dictionary of data unity.
+            key;
+            "unit_z_data"; Unity of z data.
+            "unit_z_shot"; Unity of z shot.
+
+        Returns:
+            Rpc: The object rpc.
+        """
+        obj = cls()
+        obj.fact_rpc = param_rpc["fact_rpc"]
+        obj.param_rpc["ERR_BIAS"] = -1
+        obj.param_rpc["ERR_RAND"] = -1
+
+        grid_img, grid_world = obj.create_grid_rpc(shot, cam, unit_data, param_rpc["size_grid"])
+
+        img_norm, world_norm = obj.normalize_data(grid_img, grid_world)
+
+        coeffx = obj.least_square_rpc(img_norm[0], world_norm, param_rpc["order"])
+        coeffy = obj.least_square_rpc(img_norm[1], world_norm, param_rpc["order"])
+
+        # Save param
+        obj.param_rpc["SAMP_NUM_COEFF"] = coeffx[0:20]  # X numerator
+        obj.param_rpc["SAMP_DEN_COEFF"] = coeffx[20:]  # X denominator
+        obj.param_rpc["LINE_NUM_COEFF"] = coeffy[0:20]  # Y numerator
+        obj.param_rpc["LINE_DEN_COEFF"] = coeffy[20:]  # Y denominator
+        return obj
+
+    def create_grid_rpc(self, shot: Shot, cam: Camera,
+                        unit_data: dict, size_grid: int = 100) -> tuple:
+        """
+        Creation of a grid on a size_grid buffer around the acquisition.
+
+        Args:
+            shot (Shot): The shot to create the grid.
+            cam (Camera): The camera of the shot.
+            unit_data (dict): Dictionary of data unity.
+            key;
+            "unit_z_data"; Unity of z data.
+            "unit_z_shot"; Unity of z shot.
+            size_grid (int): The size of the grid to add around the shot.
+
+        Returns:
+            tuple: Image coordinates [col, line] and world coordinates [X, Y, Z] of the grid.
+        """
+        corner_img = np.array([[0, cam.width, 0, cam.width], [0, cam.height, cam.height, 0]])
+        pt_w = ImageWorldShot(shot, cam).image_to_world(corner_img,
+                                                        unit_data["unit_z_data"],
+                                                        unit_data["unit_z_shot"])
+        pt_min = np.min(pt_w, axis=1)[0:2] - size_grid - 1
+        pt_max = np.max(pt_w, axis=1)[0:2] + size_grid + 1
+        x, y = np.mgrid[int(pt_min[0]):int(pt_max[0]) + size_grid:size_grid,
+                        int(pt_min[1]):int(pt_max[1]) + size_grid:size_grid]
+        x, y = x.ravel(), y.ravel()
+        z = np.squeeze(Dtm().get_z_world(np.array([x, y])))
+        pt_img = WorldImageShot(shot, cam).world_to_image(np.array([x, y, z]),
+                                                          unit_data["unit_z_data"],
+                                                          unit_data["unit_z_shot"])
+        return pt_img, np.array([x, y, z])
+
+    def normalize_data(self, grid_img: np.ndarray, grid_world: np.ndarray) -> tuple:
+        """
+        Normalize data grid to calculate Rpc.
+
+        Args:
+            grid_img (np.array): Image coordinates [c, l] of the grid.
+            grid_world (np.array): World coordinates [x, y, z] of the grid.
+
+        Returns:
+            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])
+        else:
+            x_geog = grid_world[0]*self.fact_rpc
+            y_geog = grid_world[1]*self.fact_rpc
+            z_geog = grid_world[2]
+
+        # Normalization of image coordinates
+        col_n_o_s = normalize(grid_img[0])
+        lin_n_o_s = normalize(grid_img[1])
+
+        # Normalization of world coordinates
+        x_n_o_s = normalize(x_geog)
+        y_n_o_s = normalize(y_geog)
+        z_n_o_s = normalize(z_geog)
+
+        self.param_rpc["LINE_OFF"] = lin_n_o_s[1]
+        self.param_rpc["SAMP_OFF"] = col_n_o_s[1]
+        self.param_rpc["LAT_OFF"] = y_n_o_s[1]
+        self.param_rpc["LONG_OFF"] = x_n_o_s[1]
+        self.param_rpc["HEIGHT_OFF"] = z_n_o_s[1]
+        self.param_rpc["LINE_SCALE"] = lin_n_o_s[2]
+        self.param_rpc["SAMP_SCALE"] = col_n_o_s[2]
+        self.param_rpc["LAT_SCALE"] = y_n_o_s[2]
+        self.param_rpc["LONG_SCALE"] = x_n_o_s[2]
+        self.param_rpc["HEIGHT_SCALE"] = z_n_o_s[2]
+
+        coor_img = np.array([col_n_o_s[0], lin_n_o_s[0]])
+        coor_world = np.array([x_n_o_s[0], y_n_o_s[0], z_n_o_s[0]])
+
+        return coor_img, coor_world
+
+    def least_square_rpc(self, img_norm: np.ndarray, world_norm: np.ndarray,
+                         polynomial_degree: int) -> np.ndarray:
+        """
+        Calcule Rpc of the shot by least square methode for one image coordinate.
+
+        Args:
+            img_norm (np.array): Normalize coordinates column or line of point in image.
+            world_norm (np.array): Normalize coordinate of world grid.
+            polynomial_degree (int): Degree of the polynomial of the rpc (1, 2, 3).
+
+        Returns:
+            np.array: Rpc coefficients.
+        """
+        mat_obs = self.setup_matrix_obs_rpc(img_norm, world_norm, polynomial_degree)
+        x = np.linalg.lstsq(mat_obs, img_norm, rcond=None)[0]
+
+        coef_rpc = np.zeros(40)
+        if polynomial_degree == 1:
+            coef_rpc[0:4] = x[0:4]
+            coef_rpc[20] = 1
+            coef_rpc[21:24] = x[4:7]
+
+        elif polynomial_degree == 2:
+            coef_rpc[0:10] = x[0:10]
+            coef_rpc[20] = 1
+            coef_rpc[21:30] = x[10:19]
+
+        elif polynomial_degree == 3:
+            coef_rpc[0:20] = x[0:20]
+            coef_rpc[20] = 1
+            coef_rpc[21:40] = x[20:39]
+
+        return coef_rpc
+
+    def setup_matrix_obs_rpc(self, img_norm: np.ndarray, world_norm: np.ndarray,
+                             polynomial_degree: int) -> np.ndarray:
+        """
+        Setup observation matrix of the rpc for least square methode.
+
+        Args:
+            img_norm (np.array): Normalize coordinates column or line of point in image.
+            world_norm (np.array): Normalize coordinate of world grid.
+            polynomial_degree (int): Degree of the polynomial of the rpc (1, 2, 3).
+
+        Returns:
+            np.array: Observation matrix of the Rpc.
+        """
+        mat_a1 = []
+        mat_a2 = []
+        ligne_a = np.ones((len(img_norm)))
+        mat_a1.append(ligne_a)
+
+        if polynomial_degree in [1, 2, 3]:
+            mat_a1.append(ligne_a * world_norm[0])
+            mat_a1.append(ligne_a * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[2])
+
+            mat_a2.append(ligne_a * -img_norm * world_norm[0])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[2])
+        else:
+            raise ValueError("The degree of the polynomial must be 1, 2 or 3")
+
+        if polynomial_degree in [2, 3]:
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[1] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[0])
+            mat_a1.append(ligne_a * world_norm[1] * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[2] * world_norm[2])
+
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[0])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1] * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[2] * world_norm[2])
+
+        if polynomial_degree == 3:
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[1] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[0] * world_norm[0])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[1] * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[2] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[0] * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[1] * world_norm[1] * world_norm[1])
+            mat_a1.append(ligne_a * world_norm[1] * world_norm[2] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[0] * world_norm[0] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[1] * world_norm[1] * world_norm[2])
+            mat_a1.append(ligne_a * world_norm[2] * world_norm[2] * world_norm[2])
+
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[1] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[0] * world_norm[0])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[1] * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[2] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[0] * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1] * world_norm[1] * world_norm[1])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1] * world_norm[2] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[0] * world_norm[0] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[1] * world_norm[1] * world_norm[2])
+            mat_a2.append(ligne_a * -img_norm * world_norm[2] * world_norm[2] * world_norm[2])
+
+        return np.concatenate((np.array(mat_a1), np.array(mat_a2)), axis=0).T

borea/geodesy/approx_euclidean_proj.py

@@ -0,0 +1,91 @@
+"""
+A module for manipulating an approximate euclidean projection.
+"""
+import numpy as np
+from borea.geodesy.euclidean_proj import EuclideanProj
+
+
+class ApproxEuclideanProj(EuclideanProj):
+    """
+     This class represents an approximate Euclidean projection system.
+
+    Args:
+        x_central (float): x coordinate of the central point of the Euclidean system.
+        y_central (float): y coordinate of the central point of the Euclidean system.
+
+    .. note::
+        A Euclidean system is a local Euclidean reference system in which
+        the collinear equation is valid.
+    """
+    def __init__(self, x_central: float, y_central: float) -> None:
+        super().__init__(x_central, y_central)
+        self.earth_raduis = 6366000
+
+    def mat_to_mat_eucli(self, x: float, y: float, mat: np.ndarray) -> np.ndarray:
+        """
+        Transform the rotation matrix (World system) into rotation matrix (Euclidian systeme).
+
+        Args:
+            x (float): x coordinate of the point.
+            y (float): y coordinate of the point.
+            mat (np.array): Rotation matrix (World system).
+
+        Returns:
+            np.array: Euclidean rotation matrix.
+        """
+        _, _ = x, y
+        return mat
+
+    def mat_eucli_to_mat(self, x: float, y: float, mat_eucli: np.ndarray) -> np.ndarray:
+        """
+        Transform the rotation matrix (Euclidean system) into rotation matrix (World system).
+
+        Args:
+            x (float): x coordinate of the point.
+            y (float): y coordinate of the point.
+            mat_eucli (np.array): Rotation matrix (Euclidean system).
+
+        Returns:
+            np.array: Rotation matrix (World system).
+        """
+        _, _ = x, y
+        return mat_eucli
+
+    def world_to_eucli(self, coor_world: np.ndarray) -> np.ndarray:
+        """
+        Transform a point from the world coordinate reference system into
+        the Euclidean coordinate reference system.
+
+        Args:
+            coor_world (np.array): World coordinate of the point [X, Y, Z].
+
+        Returns:
+            np.array: Point in the Euclidean coordinate reference system.
+        """
+        dx = coor_world[0] - self.pt_central[0]
+        dy = coor_world[1] - self.pt_central[1]
+        tt = (dx ** 2 + dy ** 2) / (4 * self.earth_raduis)
+        cc = (self.earth_raduis + coor_world[2]) / (tt + self.earth_raduis)
+        xe = dx * cc
+        ye = dy * cc
+        ze = ((self.earth_raduis - tt) * cc) - self.earth_raduis
+        return np.array([xe, ye, ze])
+
+    def eucli_to_world(self, coor_eucli: np.ndarray) -> np.ndarray:
+        """
+        Transform a point from the Euclidean coordinate reference system into
+        the world coordinate reference system.
+
+        Args:
+            coor_eucli: Euclidean coordinate of the point [X, Y, Z].
+
+        Returns:
+            np.array: Point in the World coordinate reference system.
+        """
+        rz = self.earth_raduis + coor_eucli[2]
+        rh = (rz**2 + coor_eucli[0]**2 + coor_eucli[1]**2)**0.5
+        rz = (2*self.earth_raduis)/(rz + rh)
+        x = self.pt_central[0] + (coor_eucli[0] * rz)
+        y = self.pt_central[1] + (coor_eucli[1] * rz)
+        z = rh - self.earth_raduis
+        return np.array([x, y, z])

borea/geodesy/euclidean_proj.py

@@ -0,0 +1,25 @@
+"""
+A module for manipulating an euclidean projection.
+"""
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class EuclideanProj:
+    """
+    This class represents a Euclidean projection system.
+
+    Args:
+        x_central (float): x coordinate of the central point of the Euclidean system.
+        y_central (float): y coordinate of the central point of the Euclidean system.
+
+    .. note::
+        A Euclidean system is a local Euclidean reference system in which
+        the collinear equation is valid.
+    """
+    x_central: float
+    y_central: float
+
+    def __post_init__(self) -> None:
+        self.pt_central = np.array([self.x_central, self.y_central, 0])

borea/geodesy/local_euclidean_proj.py

@@ -0,0 +1,127 @@
+"""
+A module for manipulating a local euclidean projection.
+"""
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+from borea.geodesy.proj_engine import ProjEngine
+from borea.geodesy.euclidean_proj import EuclideanProj
+from borea.utils.check.check_array import check_array_transfo
+
+
+class LocalEuclideanProj(EuclideanProj):
+    """
+    This class represents a Euclidean projection system.
+
+    Args:
+        x_central (float): x coordinate of the central point of the Euclidean system.
+        y_central (float): y coordinate of the central point of the Euclidean system.
+
+    .. note::
+        A Euclidean system is a local Euclidean reference system in which
+        the collinear equation is valid.
+        The cartographic system parameters must be known.
+    """
+    def __init__(self, x_central: float, y_central: float) -> None:
+        super().__init__(x_central, y_central)
+        self.rot_to_euclidean_local = self.mat_rot_euclidean_local(x_central, y_central)
+
+    def mat_rot_euclidean_local(self, x: float, y: float) -> np.ndarray:
+        """
+        Compute the transition matrix between the world system and
+        the Euclidean system centred on a point.
+
+        Args:
+            x (float): x coordinate of the central point of the Euclidean system.
+            y (float): y coordinate of the central point of the Euclidean system.
+
+        Returns:
+            np.array: Transition matrix.
+        """
+        lon, lat = ProjEngine().carto_to_geog(x, y)
+        gamma = ProjEngine().get_meridian_convergence(x, y)
+
+        # Matrix for switching to local cartesian coordinates
+        rot_ecef_to_eucli = R.from_euler("ZYZ", np.array([lon, 90 - lat, 90 + gamma]),
+                                         degrees=True).inv()
+        return rot_ecef_to_eucli.as_matrix()
+
+    def mat_to_mat_eucli(self, x: float, y: float, mat: np.ndarray) -> np.ndarray:
+        """
+        Transform the rotation matrix (World system) into rotation matrix (Euclidian systeme).
+
+        Args:
+            x (float): x coordinate of the point.
+            y (float): y coordinate of the point.
+            mat (np.array): Rotation matrix (World system).
+
+        Returns:
+            np.array: Euclidean rotation matrix.
+        """
+        # We are in the projection system, we pass into the local tangeant system
+        matecef_to_rtl = self.mat_rot_euclidean_local(x, y)
+        mat_eucli = mat @ matecef_to_rtl @ self.rot_to_euclidean_local.T
+        return mat_eucli
+
+    def mat_eucli_to_mat(self, x: float, y: float, mat_eucli: np.ndarray) -> np.ndarray:
+        """
+        Transform the rotation matrix (Euclidean system) into rotation matrix (World system).
+
+        Args:
+            x (float): x coordinate of the point.
+            y (float): y coordinate of the point.
+            mat_eucli (np.array): Rotation matrix (Euclidean system).
+
+        Returns:
+            np.array: Rotation matrix (World system).
+        """
+        # We're in the local tangeant frame, now we're in the projection frame
+        matecef_to_rtl = self.mat_rot_euclidean_local(x, y)
+        mat = mat_eucli @ self.rot_to_euclidean_local @ matecef_to_rtl.T
+        return mat
+
+    def world_to_eucli(self, coor: np.ndarray) -> np.ndarray:
+        """
+        Transform a point from the world coordinate reference system into
+        the Euclidean coordinate reference system.
+
+        Args:
+            coor (np.ndarray): Coordinate [X, Y, Z].
+
+        Returns:
+            np.array: x, y, z in the Euclidean coordinate reference system.
+        """
+        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]))
+        dr = np.vstack([coor_geoc[0] - central_geoc[0],
+                        coor_geoc[1] - central_geoc[1],
+                        coor_geoc[2] - central_geoc[2]])
+        point_eucli = np.squeeze((self.rot_to_euclidean_local @ dr) + np.array([self.pt_central]).T)
+        return point_eucli
+
+    def eucli_to_world(self, coor: np.ndarray) -> np.ndarray:
+        """
+        Transform a point from the Euclidean coordinate reference system into
+        the world coordinate reference system.
+
+        Args:
+            coor (np.ndarray): Coordinate [X, Y, Z].
+
+        Returns:
+            np.array: x, y, z in the world coordinate reference system.
+        """
+        coor = np.squeeze(coor)
+
+        central_geoc = np.array(ProjEngine().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)
+        return np.array([tup[0], tup[1], tup[2]])