ign-borea 0.1.5__py3-none-any.whl

borea/transform_world_image/transform_worksite/space_resection.py

@@ -0,0 +1,343 @@
+"""
+Module for recalculate shooting position
+"""
+import pandas as pd
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+from borea.utils.miscellaneous.miscellaneous import angle_degree_2vect, min_max_pt, normalize
+from borea.worksite.worksite import Worksite
+from borea.datastruct.camera import Camera
+from borea.datastruct.shot import Shot
+from borea.transform_world_image.transform_shot.world_image_shot import WorldImageShot
+from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
+# 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
+
+
+class SpaceResection:
+    """
+    Recalculates the shot's 6 external orientation parameters,
+    the 3 angles omega, phi, kappa and its position x, y, z.
+
+    Args:
+        work (Woksite): Worksite to make space resection
+    """
+    def __init__(self, work: Worksite) -> None:
+        self.work = work
+
+    def space_resection_to_worksite(self, pt2d: pd.DataFrame, pt3d: pd.DataFrame,
+                                    pinit: dict) -> None:
+        """
+        Calculates the shot's 6 external orientation parameters,
+        the 3 angles omega, phi, kappa and its position x, y, z.
+        For all shot with a variation pixel.
+
+        Args:
+            pt2d (pd.Dataframe): Table of image coordinate point with image.
+            pt3d (pd.Dataframe): Table of ground coordinate point.
+            pinit (dict): Dictionnary with 3d coordinate for initialization "coor_init".
+        """
+        for name_shot, group in pt2d.groupby("id_shot"):
+            if group.shape[0] < 3:
+                print(f"Shot {name_shot} has fewer than three points,"
+                      " so it cannot calculate its position and orientation.")
+                continue
+
+            dfm = group.merge(pt3d, how="inner", on="id_pt")
+            obs_img = np.array([dfm["column"].to_numpy(), dfm["line"].to_numpy()])
+            obs_world = np.array([dfm["x"].to_numpy(), dfm["y"].to_numpy(), dfm["z"].to_numpy()])
+
+            pinit["kappa"] = self.init_kappa(dfm)
+            self.work.shots[name_shot] = self.space_resection_shot(name_shot, obs_img,
+                                                                   obs_world, pinit)
+        self.work.set_param_shot(self.work.approxeucli)
+
+        if pt3d["type"].iloc[0]:
+            type_pt = "gcp2d"
+        else:
+            type_pt = "co_points"
+        self.work.set_point_image_dataframe(pt2d, type_pt)
+        self.work.set_point_world_dataframe(pt3d, type_pt)
+
+    def space_resection_on_worksite(self, add_pixel: tuple = (0, 0)) -> None:
+        """
+        Recalculates the shot's 6 external orientation parameters,
+        the 3 angles omega, phi, kappa and its position x, y, z.
+        For all shot with a variation pixel.
+
+        Args:
+            add_pixel (tuple): Factor (column, line) added on observable point.
+        """
+        for key_shot, item_shot in self.work.shots.items():
+            self.work.shots[key_shot] = self.space_resection_gap(item_shot, add_pixel)
+
+    def space_resection_shot(self, name_shot: str, pt_img: np.ndarray,
+                             pt_world: np.ndarray, pinit: dict) -> Shot:
+        """
+        Calculates the shot's 6 external orientation parameters,
+        the 3 angles omega, phi, kappa and its position x, y, z.
+
+        Args:
+            name_shot (str): Name of shot to calculte externa parameters.
+            pt_img (np.array): Coordonnees image of points.
+            pt_world (np.array): Coordonnees world of points.
+            pinit (dict): Dictionnary with 3d coordinate for initialization and kappa.
+
+        Returns:
+            Shot: Adjusted shot.
+        """
+        # Initialization of adjusted shot
+        cam = self.work.cameras[list(self.work.cameras.keys())[0]]
+        shot_adjust = Shot(name_shot, pinit["coor_init"], np.array([0, 0, pinit["kappa"]]),
+                           cam.name_camera, "degree", False, "opk")
+        shot_adjust.set_param_eucli_shot(self.work.approxeucli)
+        z_nadir = ImageWorldShot(shot_adjust, cam).image_to_world(np.array([cam.ppax, cam.ppay]),
+                                                                  self.work.type_z_shot,
+                                                                  self.work.type_z_shot, False)[2]
+        shot_adjust.set_z_nadir(z_nadir)
+
+        # Calculate euclidean position
+        pt_eucli = shot_adjust.projeucli.world_to_eucli(pt_world)
+
+        # Least-square methode
+        shot_adjust = self.least_square_shot(shot_adjust, pt_img, pt_eucli, pt_world)
+
+        return shot_adjust
+
+    def init_kappa(self, dfpt: pd.DataFrame) -> float:
+        """
+        Calculates a kappa angle for acquisition initialization.
+
+        Args:
+            dfpt (pd.DataFrame): Coordonnees of points in image and world.
+
+        Returns:
+            float: kappa angle.
+        """
+        pt_img = np.array([dfpt["column"].to_numpy(), dfpt["line"].to_numpy()])
+        pt_mini, arg_min = min_max_pt(pt_img, "min")
+        pt_maxi, arg_max = min_max_pt(pt_img, "max")
+        pt_minw = dfpt.iloc[arg_min].get(["x", "y"]).to_numpy()
+        pt_maxw = dfpt.iloc[arg_max].get(["x", "y"]).to_numpy()
+        vect_i = pt_maxi - pt_mini
+        vect_w = pt_maxw - pt_minw
+        norm_vi = normalize(vect_i)[0]
+        norm_vw = normalize(vect_w)[0]
+        kappa = angle_degree_2vect(norm_vi, norm_vw)
+        return np.floor(kappa)
+
+    def space_resection_gap(self, shot: Shot, add_pixel: tuple = (0, 0)) -> Shot:
+        """
+        Recalculates the shot's 6 external orientation parameters,
+        the 3 angles omega, phi, kappa and its position x, y, z.
+
+        Args:
+            shot (Shot): Shot to recalculte externa parameters.
+            add_pixel (tuble): Pixel to be added to change marker.
+
+        Returns:
+            Shot: Adjusted shot.
+        """
+        # Initialization observation point
+        obs, pt_world = self.take_obs(shot)
+
+        # Calculate euclidean position
+        pt_eucli = shot.projeucli.world_to_eucli(pt_world)
+
+        # Add factor
+        obs[0] += add_pixel[0]
+        obs[1] += add_pixel[1]
+
+        # Initialization of adjusted shot
+        shot_adjust = Shot(shot.name_shot, shot.pos_shot, shot.ori_shot,
+                           shot.name_cam, shot.unit_angle, shot.linear_alteration, shot.order_axe)
+        shot_adjust.set_param_eucli_shot(shot.approxeucli)
+        shot_adjust.set_z_nadir(shot.z_nadir)
+
+        # Least-square methode
+        shot_adjust = self.least_square_shot(shot_adjust, obs, pt_eucli, pt_world)
+
+        shot_adjust.co_points = shot.co_points
+        shot_adjust.gcp2d = shot.gcp2d
+        shot_adjust.gcp3d = shot.gcp3d
+
+        return shot_adjust
+
+    def least_square_shot(self, shot_adjust: Shot, obs: np.ndarray,
+                          pt_eucli: np.ndarray, pt_world: np.ndarray) -> Shot:
+        """
+        Least-square methode to calcule the shot's 6 external orientation parameters.
+
+        Args:
+            shot_adjust (Shot): The shot to adjust.
+            obs (np.array): Observation of point in image [c_obs, l_obs].
+            pt_eucli (np.array): Observation of world point in euclidean system [X, Y, Z].
+            pt_world (np.array): Observation of world point [X, Y, Z].
+
+        Returns:
+            Shot: Adjusted shot.
+        """
+        bool_iter = True
+        count_iter = 0
+        while bool_iter:
+            count_iter += 1
+
+            dx = self.func_least_square(shot_adjust, obs, pt_eucli, pt_world)
+
+            # Calculate new x = x0 + dx for position and rotation matrix
+            new_pos_eucli = np.array([shot_adjust.pos_shot[0] + dx[0],
+                                      shot_adjust.pos_shot[1] + dx[1],
+                                      shot_adjust.pos_shot[2] + dx[2]])
+            new_mat_eucli = shot_adjust.mat_rot_eucli @ R.from_rotvec(dx[3:]).as_matrix()
+
+            # Creation of new shot with new parameter
+            imc_new_adjust = Shot.from_param_euclidean(shot_adjust.name_shot, new_pos_eucli,
+                                                       new_mat_eucli, shot_adjust.name_cam,
+                                                       shot_adjust.unit_angle,
+                                                       shot_adjust.linear_alteration,
+                                                       shot_adjust.order_axe,
+                                                       shot_adjust.approxeucli)
+            imc_new_adjust.set_z_nadir(shot_adjust.z_nadir)
+
+            # Look difference to know if you want to stop the calculation
+            diff_coord = np.array([imc_new_adjust.pos_shot]) - np.array([shot_adjust.pos_shot])
+            diff_opk = np.array([imc_new_adjust.ori_shot]) - np.array([shot_adjust.ori_shot])
+
+            if (np.all(diff_coord < 10 ** -3) and np.all(diff_opk < 10 ** -6)) or count_iter > 100:
+                # print(count_iter)
+                bool_iter = False
+
+            # Replace adjusted place
+            shot_adjust = imc_new_adjust
+
+        return shot_adjust
+
+    def func_least_square(self, shot_adjust: Shot, obs: np.ndarray,
+                          pt_eucli: np.ndarray, pt_world: np.ndarray) -> np.ndarray:
+        """
+        Calculate the least-squares equation dx = (A.T @ A)**-1 @ A.T @ B
+
+        Args:
+            shot_adjust (Shot): The shot to adjust.
+            obs (np.array): Observation of point in image [c_obs, l_obs].
+            pt_eucli (np.array): Observation of world point in euclidean system [X, Y, Z].
+            pt_world (np.array): Observation of world point [X, Y, Z].
+
+        Returns:
+            np.array: dx.
+        """
+        cam = self.work.cameras[shot_adjust.name_cam]
+        # Calculate position column and line with new shot f(x0)
+        f0 = WorldImageShot(shot_adjust,
+                            cam
+                            ).world_to_image(pt_world,
+                                             self.work.type_z_data,
+                                             self.work.type_z_shot)
+
+        # Calculate residual vector B
+        v_res = np.c_[obs[0] - f0[0], obs[1] - f0[1]].reshape(2 * len(pt_eucli[0]))
+
+        # 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])
+
+    def mat_obs_axia(self, pt_eucli: np.ndarray, imc_adjust: Shot) -> np.ndarray:
+        """
+        Setting up the mat_a matrix to solve the system by axiator.
+
+        Args:
+            pt_eucli (np.array): Coordinate [X, Y, Z] euclidean.
+            imc_adjust (Shot): adjusted shot.
+
+        Returns:
+            np.array: Matrix A.
+        """
+        vect_a, vect_u, mat_v = set_param_bundle_diff(imc_adjust, pt_eucli)
+
+        # Axiator of vect_a
+        a_axiator = np.zeros((3 * len(vect_a[0]), 3))
+        a_axiator[0::3, 1] = -vect_a[2]
+        a_axiator[0::3, 2] = vect_a[1]
+        a_axiator[1::3, 0] = vect_a[2]
+        a_axiator[1::3, 2] = -vect_a[0]
+        a_axiator[2::3, 0] = -vect_a[1]
+        a_axiator[2::3, 1] = vect_a[0]
+
+        cam = self.work.cameras[imc_adjust.name_cam]
+        mat_a = -np.tile(np.repeat(cam.focal / vect_u[2] ** 2, 2), (6, 1)).T
+        mat_a[:, :3] *= (mat_v @ imc_adjust.mat_rot_eucli)
+
+        mat_a[:, 3:] *= np.einsum('lij, ljk->lik',
+                                  (mat_v @ imc_adjust.mat_rot_eucli).reshape(-1, 2, 3),
+                                  # pylint: disable-next=too-many-function-args
+                                  a_axiator.reshape(-1, 3, 3)).reshape(-1, 3)
+
+        return mat_a
+
+    def take_obs(self, shot: Shot) -> tuple:
+        """
+        Check co point on the shot to use in observation.
+        If there aren't enough points, add 20 random observation points.
+
+        Args:
+            shot (Shot): The shot to adjust.
+
+        Returns:
+            tuple: np.array(obs_image), np.array(pt_world).
+        """
+        add_pt = True
+        pt_world_random = 0
+        if shot.co_points:
+            if not self.work.co_pts_world:
+                WorldIntersection(self.work).calculate_image_world_by_intersection("co_points")
+            obs, pt_world = self.work.get_coor_pt_img_and_world(shot.name_shot, "co_points")
+            if obs.shape[1] >= 7:
+                add_pt = False
+
+        if add_pt:
+            cam = self.work.cameras[shot.name_cam]
+            # Initialization of 20 points for shooting position
+            obs_random, z_world = self.seed_20_point(cam)
+            # Calculate world position
+            x_world, y_world, _ = ImageWorldShot(shot,
+                                                 cam
+                                                 ).image_z_to_world(obs_random,
+                                                                    self.work.type_z_shot,
+                                                                    z_world)
+            pt_world_random = np.array([x_world, y_world, z_world])
+
+        if add_pt and shot.co_points:
+            obs = np.concatenate((obs, obs_random), axis=1)
+            pt_world[2] += 350  # 350 is the mean of z_obs in seed_20_point
+            pt_world = np.concatenate((pt_world, pt_world_random), axis=1)
+            add_pt = False
+
+        if add_pt:
+            obs = obs_random
+            pt_world = pt_world_random
+
+        return obs, pt_world
+
+    def seed_20_point(self, cam: Camera) -> tuple:
+        """
+        Positioning of 20 points on an image by percentage position on width and height.
+        The z-world position is given by fixed values.
+
+        Args:
+            cam (Camera): Camera of the shot.
+
+        Returns:
+            np.array: Tuple of 3 elements (position column obs, position line obs, z world).
+        """
+        pourcent_x = np.array([6.25, 12.5, 18.75, 25, 31.25, 37.5, 37.5, 43.75, 50, 56.25,
+                               62.5, 62.5, 68.75, 68.75, 75, 81.25, 87.5, 87.5, 93.75, 93.75]) / 100
+        pourcent_y = np.array([80, 20, 60, 90, 30, 10, 50, 70, 20, 40,
+                               60, 90, 20, 80, 50, 20, 10, 70, 40, 90]) / 100
+        z_obs = np.array([200, 320, 250, 240, 330, 335, 340, 330, 350, 360,
+                          360, 350, 370, 355, 380, 400, 450, 400, 500, 300])
+        c_obs = pourcent_x * cam.width
+        l_obs = pourcent_y * cam.height
+
+        return np.array([c_obs, l_obs]), z_obs

borea/transform_world_image/transform_worksite/world_image_work.py

@@ -0,0 +1,43 @@
+"""
+World image transformation module for Worksite
+"""
+from dataclasses import dataclass
+from borea.worksite.worksite import Worksite
+from borea.transform_world_image.transform_shot.world_image_shot import WorldImageShot
+
+
+@dataclass
+class WorldImageWork:
+    """
+    Class to calculate world coordinate to image coordinate in worksite.
+
+    Args:
+        name (str): Name of the worksite.
+    """
+    work: Worksite
+
+    def calculate_world_to_image(self, lcode: list) -> None:
+        """
+        Calculates the position of gcp3d which corresponds to the data code
+        in the images they appear in.
+
+        Args:
+            lcode (list): gcp code.
+        """
+        if self.work.gcp3d and self.work.gcp2d:
+            for name_gcp, gcp in self.work.gcp3d.items():
+                if gcp.code in lcode or lcode == []:
+                    try:
+                        list_shots = self.work.gcp2d[name_gcp]
+                        for name_shot in list_shots:
+                            shot = self.work.shots[name_shot]
+                            cam = self.work.cameras[shot.name_cam]
+                            coor_img = WorldImageShot(shot,
+                                                      cam).world_to_image(gcp.coor,
+                                                                          self.work.type_z_data,
+                                                                          self.work.type_z_shot)
+                            self.work.shots[name_shot].gcp3d[name_gcp] = coor_img
+                    except KeyError:
+                        print(f"Warning: id point {name_gcp} is present "
+                              "in gcp3d but not in gcp2d.")
+                        continue

borea/utils/check/check_args_opk.py

@@ -0,0 +1,59 @@
+"""
+A script for verification header str in manage reader.
+"""
+from borea.utils.check.check_header import check_head, check_h_z, get_type_z_and_header
+
+
+def check_args_opk(args: dict) -> tuple:
+    """
+    Check args for reading an oopk.
+
+    Args:
+        args (dict): Information for reading an opk file.
+                     keys:
+                     "interval" (list): Interval of lines taken into account,
+                     [i, j] if i or j is None = :. e.g. [1, None] = [1:].
+                     "header" (list): List of column type file.
+                     "unit_angle" (str): Unit of angle 'degrees' or 'radian'.
+                     "linear_alteration" (bool): True if data corrected by linear alteration.
+
+    Return:
+        tuple: args, header and type of z shot.
+    """
+    if args["unit_angle"] not in ["degree", "radian"]:
+        raise ValueError(f"Unit angles is incorrect {args['unit_angle']},"
+                         "correct writing is degree or radian.")
+
+    if args["interval"][0] is not None and args["interval"][0] > 0:
+        args["interval"][0] -= 1
+    if args["interval"][1] is not None:
+        args["interval"][1] -= 1
+
+    header, type_z = check_header_file(args["header"])
+
+    return args, header, type_z
+
+
+def check_header_file(header: list) -> tuple:
+    """
+    Check if the header of the file is good.
+
+    Args:
+        header (list): List of column type file.
+
+    Returns:
+        tuple: Header without type, type of z, type of angle.
+    """
+    list_letter = ['S', 'N', 'X', 'Y', 'Z', 'H', 'O', 'P', 'K', 'C']
+
+    bad_head, ms_error_letter, head, symbol = check_head(header, list_letter)
+
+    misss = set(list_letter[1:]) - symbol
+    bad_head, ms_error_letter = check_h_z(bad_head, misss, ms_error_letter)
+
+    ms_error = "Your header is not correct.\n"
+    ms_error += ms_error_letter
+    if bad_head:
+        raise ValueError(ms_error)
+
+    return get_type_z_and_header(head)

borea/utils/check/check_args_reader_pt.py

@@ -0,0 +1,44 @@
+"""
+A script for verification args to read a point file.
+"""
+from borea.utils.check.check_header import check_head, check_h_z, get_type_z_and_header
+
+
+def check_header_file(header: list, type_pt: str) -> tuple:
+    """
+    Check if the header of the file is good.
+
+    Args:
+        header (list): List of column type file.
+        type_pt (str): Type of point is reading (co_point, gcp2d, gcp3d).
+
+    Returns:
+        tuple: header, type_z
+    """
+    type_z = None
+    list_letter = ['S', 'N', 'X', 'Y', 'Z', 'H', 'P', 'T']
+
+    bad_head, ms_error_letter, _, symbol = check_head(header, list_letter)
+
+    if type_pt in ["gcp3d", "pt3d"]:
+        ll_type = ['P', 'T', 'X', 'Y', 'Z', 'H']
+        misss = set(ll_type) - symbol
+        if misss != set() and misss != set("T"):
+            if "T" in misss:
+                misss.remove("T")
+            bad_head, ms_error_letter = check_h_z(bad_head, misss, ms_error_letter)
+        if not bad_head:
+            header, type_z = get_type_z_and_header(header)
+    else:
+        ll_type = ['P', 'N', 'X', 'Y']
+        misss = set(ll_type) - symbol
+        if misss != set():
+            bad_head = True
+            ms_error_letter += f"The letters {misss} are missing.\n"
+
+    ms_error = "Your header is not correct.\n"
+    ms_error += ms_error_letter
+    if bad_head:
+        raise ValueError(ms_error)
+
+    return header, type_z

borea/utils/check/check_array.py

@@ -0,0 +1,56 @@
+"""
+A script combining various data conversion and format verification functions.
+"""
+from typing import Union
+import numpy as np
+
+
+def check_array_transfo(x: Union[np.ndarray, float],
+                        y: Union[np.ndarray, float],
+                        z: Union[np.ndarray, float] = None) -> tuple:
+    """
+    Checks the dimension of vectors if dim = 1 outputs the element in a variable.
+    x,y,z are in the same dimension and they must be vectors if array
+    possible dimension if array : (1,), (n,), (n,1) or (1,n).
+
+    Args:
+        x (Union[np.array, float]): Vector x.
+        y (Union[np.array, float]): Vector y.
+        z (Union[np.array, float]): Vector z.
+
+    Returns:
+        tuple: x, y, z.
+    """
+    if isinstance(x, np.ndarray):  # look if is an array
+        t = np.shape(x)
+        if len(t) == 1:  # look dim == (n,)
+            if t[0] == 1:  # look n == 1
+                # takes out the elements
+                x = float(x[0])
+                y = float(y[0])
+                if z is not None:
+                    z = float(z[0])
+
+        if len(t) == 2:  # look dim == (n,m)
+            if t[0] != 1:  # look n != 1
+                # conversion dim (n,1) to (1,n)
+                x = x.T
+                y = y.T
+                if z is not None:
+                    z = z.T
+            # conversion dim (1,n) to (n,)
+            x = np.squeeze(x, axis=0)
+            y = np.squeeze(y, axis=0)
+            if z is not None:
+                z = np.squeeze(z, axis=0)
+
+            # same checkup to the top
+            t2 = np.shape(x)
+            if len(t2) == 1:
+                if t2[0] == 1:
+                    x = float(x[0])
+                    y = float(y[0])
+                    if z is not None:
+                        z = float(z[0])
+
+    return x, y, z

borea/utils/check/check_header.py

@@ -0,0 +1,90 @@
+"""
+A script for verification header list str.
+"""
+
+
+def check_head(header: list, check_letter: list) -> tuple:
+    """
+    Checks that the header contains all the letters in the check letter.
+
+    Args:
+        header (list): List of column type file.
+        check_letter (list): List of good letter in header.
+
+    Returns:
+        tuple: bad_head, ms_error, head, symbol
+    """
+    bad_head = False
+    ms_error_letter = ""
+    symbol = set()
+    head = []
+
+    for l_type in header:
+        if l_type in check_letter:
+            if l_type not in head or l_type == "S":
+                head.append(l_type)
+                if l_type != "S":
+                    symbol.add(l_type)
+            else:
+                bad_head = True
+                ms_error_letter += f"Symbol {l_type} appears several times, "
+                ms_error_letter += "this is incorrect, must appear only once\n"
+        else:
+            bad_head = True
+            ms_error_letter += f"Symbol {l_type} is not recognized, "
+            ms_error_letter += f"list of symbol recognized {check_letter}\n"
+
+    return bad_head, ms_error_letter, head, symbol
+
+
+def check_h_z(bad_head: bool, misss: set, ms_error_letter: str) -> tuple:
+    """
+    Check letter H and Z in header.
+
+    Args:
+        bad_head (bool): boolean if the header is false.
+        misss (set): Diff between list_letter and symbol.
+        ms_error_letter (str): Error message.
+
+    Returns:
+        tuple: bad_head, ms_error_letter
+    """
+    if misss != {"Z"} and misss != {"H"} and misss != set():
+        bad_head = True
+        if "Z" in misss and "H" in misss:
+            miss = misss.copy()
+            miss.remove("Z")
+            miss.remove("H")
+            ms_error_letter += f"The letters 'Z' or 'H' are missing and lettres {miss}.\n"
+        elif "Z" in misss:
+            misss.remove("Z")
+            ms_error_letter += f"The letters {misss} are missing.\n"
+        else:
+            misss.remove("H")
+            ms_error_letter += f"The letters {misss} are missing.\n"
+
+    if misss == set():
+        bad_head = True
+        ms_error_letter += "The letters Z and H cannot be in the same string.\n"
+
+    return bad_head, ms_error_letter
+
+
+def get_type_z_and_header(header: list) -> tuple:
+    """
+    Return type of z, height if H and altitude if Z
+    and header with the H replaced by a Z.
+
+    Args:
+        header (list): List of column type file.
+
+    Returns:
+        tuple: Header and type_z.
+    """
+    if "H" in header:
+        type_z = "height"
+        header[header.index('H')] = "Z"
+    else:
+        type_z = "altitude"
+
+    return header, type_z

borea/utils/check/check_order_axe.py

@@ -0,0 +1,50 @@
+"""
+Script to check order axe and return axe for scipy
+"""
+from borea.utils.check.check_header import check_head
+
+
+def check_order_axe(order_axe: str) -> str:
+    """
+    Check if code is good and convert for scipy rotation.
+
+    Args:
+        order_axe (str): Order of rotation matrix axes.
+
+    Retuns:
+        str: Order of ratation matrix axe for scipy.
+    """
+    list_val = ['o', 'p', 'k']
+
+    bad_head, ms_error_letter, _, symbol = check_head(list(order_axe), list_val)
+
+    misss = set(list_val) - symbol
+    if misss != set():
+        bad_head = True
+        ms_error_letter += f"The letters {misss} are missing.\n"
+
+    ms_error = "Your order axe is not correct.\n"
+    ms_error += ms_error_letter
+    if bad_head:
+        raise ValueError(ms_error)
+
+    return convert_opk_to_xyz(order_axe)
+
+
+def convert_opk_to_xyz(order_axe: str) -> str:
+    """
+    Convert for scipy formalism.
+
+    Args:
+        order_axe (str): Order of rotation matrix axes.
+
+    Retuns:
+        str: Order of ratation matrix axe for scipy.
+    """
+    letter_conv = {"o": "x", "p": "y", "k": "z"}
+
+    form_xyz = ""
+    for i in order_axe:
+        form_xyz += letter_conv[i]
+
+    return form_xyz