ign-borea 0.1.5__py3-none-any.whl

borea/utils/miscellaneous/miscellaneous.py

@@ -0,0 +1,83 @@
+"""
+Function to normalize data.
+"""
+import numpy as np
+
+
+def normalize(array: np.ndarray) -> tuple:
+    """
+    Normalize array.
+
+    Args:
+        array (np.array): Array data to normalize.
+
+    Returns:
+        tuple: data normalize, offset of data and scale of data.
+    """
+    offset = (np.min(array) + np.max(array))/2
+    scale = (np.max(array) - np.min(array))/2
+    array_norm = (array - offset) / scale
+    return array_norm, offset, scale
+
+
+def dist_2pts(pt1: np.ndarray, pt2: np.ndarray) -> float:
+    """
+    Calculate the distance of two points.
+
+    Args:
+        pt1 (np.array): Coordinates of the first point.
+        pt2 (np.array): Coordinates of the second point.
+
+    Returns:
+        float: The distance.
+    """
+    return np.linalg.norm(pt1 - pt2)
+
+
+def min_max_pt(array: np.ndarray, type_m: str) -> tuple:
+    """
+    Get min or max of coordinnate 2D in an array of dim (2,n).
+
+    Args:
+        array (np.array): Array data to get min or max.
+        type_m (str): Type min or max.
+
+    Returns:
+        tuple: min or max Coordinate of one point and index in array.
+    """
+    if type_m == "min":
+        func = np.argmin
+    else:
+        func = np.argmax
+
+    arg_col = func(array[0])
+    arg_lin = func(array[1])
+    pt_col = array[:, arg_col]
+    pt_lin = array[:, arg_lin]
+
+    if (pt_col == pt_lin).all():
+        return pt_col, arg_col
+
+    d1 = dist_2pts(np.array([0, 0]), pt_col)
+    d2 = dist_2pts(np.array([0, 0]), pt_lin)
+    if (d1 <= d2 and type_m == "min") or (d1 >= d2 and type_m == "max"):
+        return pt_col, arg_col
+
+    return pt_lin, arg_lin
+
+
+def angle_degree_2vect(u: np.ndarray, v: np.ndarray) -> float:
+    """
+    Calculates degree angle between two vectors.
+
+    Args:
+        u (np.array): Fisrt vector.
+        v (np.array): Second vector.
+
+    Returns:
+        float: Degree angle between two vectors.
+    """
+    nu = np.linalg.norm(u)
+    nv = np.linalg.norm(v)
+    costheta = (u @ v)/(nu * nv)
+    return np.arccos(costheta)*180/np.pi

borea/utils/miscellaneous/param_bundle.py

@@ -0,0 +1,36 @@
+"""
+Module math for bundle parameter.
+"""
+import numpy as np
+from borea.datastruct.shot import Shot
+
+
+def set_param_bundle_diff(shot: Shot, coor_eucli: np.ndarray) -> tuple:
+    """
+    Setting up the A vector, U vector and V matrix parameters for the differential function
+    of beam parameters, in the Euclidean reference frame.
+    A = M - S
+    U = R @ A
+    U = [u1, u2, u3]
+    V = [[u3, 0,-u1][ 0,u3,-u2]]
+    M euclidean point, S euclidean position shot, R rotation matrix euclidean to image.
+
+    Args:
+        shot (Shot): The shot in which we work.
+        coor_eucli (np.array): Euclidean coordinates of the point.
+
+    Returns:
+        tuple: vector A, vector U and matrix V.
+    """
+    vect_a = np.vstack([coor_eucli[0] - shot.pos_shot_eucli[0],
+                        coor_eucli[1] - shot.pos_shot_eucli[1],
+                        coor_eucli[2] - shot.pos_shot_eucli[2]])  # vect_a = M-S
+    vect_u = shot.mat_rot_eucli @ vect_a  # U = RA
+
+    mat_v = np.zeros((2 * len(vect_u[0]), 3))
+    mat_v[::2, 0] = vect_u[2]
+    mat_v[::2, 2] = -vect_u[0]
+    mat_v[1::2, 1] = vect_u[2]
+    mat_v[1::2, 2] = -vect_u[1]
+
+    return vect_a, vect_u, mat_v

borea/utils/miscellaneous/sparse.py

@@ -0,0 +1,31 @@
+"""
+Module math
+"""
+from scipy.sparse import coo_matrix
+import numpy as np
+
+
+def invert_diag_sparse_matrix_3_3(mat_inv: np.ndarray) -> np.ndarray:
+    """
+    Block matrix inversion.
+
+    Args:
+        mat (np.array): Matrix to flip.
+
+    Returns:
+        np.array: Flip matrix.
+    """
+    mat = np.c_[np.pad(mat_inv.diagonal(-2), (2, 0)),
+                np.pad(mat_inv.diagonal(-1), (1, 0)),
+                mat_inv.diagonal(0),
+                np.pad(mat_inv.diagonal(1), (0, 1)),
+                np.pad(mat_inv.diagonal(2), (0, 2))]
+
+    mat[::3, :] = np.roll(mat[::3, :], -2)
+    mat[1::3, :] = np.roll(mat[1::3, :], -1)
+
+    data = np.linalg.inv(mat[:, :-2].reshape(1, -1, 3, 3)).flatten()
+    coord_i = np.repeat(np.arange(mat_inv.shape[0]), 3)
+    coord_j = np.tile(np.arange(mat_inv.shape[0]).reshape(-1, 3), 3).flatten()
+
+    return coo_matrix((data, (coord_i, coord_j)), shape=mat_inv.shape).tocsr()

borea/utils/singleton/singleton.py

@@ -0,0 +1,23 @@
+"""
+Module for class singleton
+"""
+
+
+class Singleton(type):
+    """
+    Class Singleton for Dtm and ProjEngine.
+    It's a design pattern, belonging to the category of creation patterns,
+    whose aim is to restrict the instantiation of a class to a single object.
+    """
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+    def clear(cls):
+        """
+        Clear instances
+        """
+        _ = cls._instances.pop(cls, None)

borea/utils/xml/xml.py

@@ -0,0 +1,63 @@
+"""
+Function to implement xml.
+"""
+import xml.etree.ElementTree as ET
+import numpy as np
+
+
+def format_xml(elem: any, prec: str = ".5f") -> str:
+    """
+    Write item in xml format.
+
+    Args:
+        elem (any): The element to write in xml format.
+        prec (str): Precision of the element if is a number.
+
+    Returns:
+        str: elem in xml format.
+    """
+    if isinstance(elem, float) and np.isnan(elem):
+        return "0.00000"
+    if isinstance(elem, (float, np.float32, np.float64)):
+        return f"{elem:{prec}}"
+    if elem is None:
+        return ""
+
+    return f"{elem}"
+
+
+def indent(elem: ET, level: int = 0) -> None:
+    """
+    Structure the xml file.
+
+    Args:
+        elem (ET): The xml to write.
+        level (int): Level of structure.
+    """
+    i = "\n" + level * "  "
+    if len(elem):
+        if not elem.text or not elem.text.strip():
+            elem.text = i + "  "
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+        for subelem in elem:
+            indent(subelem, level + 1)
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+    else:
+        if level and (not elem.tail or not elem.tail.strip()):
+            elem.tail = i
+
+
+def add_elem(xml: ET, balises: list, vals: list, prec: str = ".5f") -> None:
+    """
+    Add a list of element to the ET.
+
+    Args:
+        xml (ET): The xml to add elem.
+        balises (list): List of name of the balise.
+        vals (list): List of item to put on.
+        prec (str): Precision of the element if is a number.
+    """
+    for balise, val in zip(balises, vals):
+        ET.SubElement(xml, balise).text = format_xml(val, prec)

borea/worksite/worksite.py

@@ -0,0 +1,240 @@
+"""
+Worksite data class module.
+"""
+import numpy as np
+import pandas as pd
+from borea.datastruct.dtm import Dtm
+from borea.datastruct.workdata import Workdata
+from borea.geodesy.proj_engine import ProjEngine
+from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
+
+
+class Worksite(Workdata):
+    """
+    Worksite class, class main of the tools.
+
+    Args:
+        name (str): Name of the worksite.
+    """
+
+    def get_point_image_dataframe(self, type_point: str, control_type: list = None) -> pd.DataFrame:
+        """
+        Retrieves id_pt, id_img, column, line in a pandas of the requested point type.
+
+        Args:
+            type_point (str): "co_points" or "gcp2d" depending on what you want to get.
+            control_type (list): Type controle for gcp.
+
+        Returns:
+            pandas: Pandas table.
+        """
+        if type_point not in ["co_points", "gcp2d", "gcp3d"]:
+            raise ValueError(f"type_point {type_point} is incorrect,['co_points','gcp2d','gcp3d']")
+
+        if type_point == "co_points" or not control_type:
+            control_type = []
+
+        type_iter = type_point if type_point != "gcp3d" else "gcp2d"
+
+        id_pt = []
+        id_img = []
+        coor = []
+        for name_pt, list_shot in getattr(self, type_iter).items():
+            if control_type and self.gcp3d[name_pt].code not in control_type:
+                continue
+            for name_shot in list_shot:
+                id_pt.append(name_pt)
+                id_img.append(name_shot)
+                coor.append(getattr(self.shots[name_shot], type_point)[name_pt])
+
+        coor = np.array(coor)
+        return pd.DataFrame({"id_pt": id_pt, "id_img": id_img,
+                             "column": coor[:, 0], "line": coor[:, 1]})
+
+    def set_point_image_dataframe(self, pd_mes: pd.DataFrame, type_point: str) -> None:
+        """
+        Set requested point type by pandas table id_pt, id_img, column, line.
+
+        Args:
+            pd_mes (pd): Pandas table of data.
+            type_point (str): "co_points" or "gcp2d" depending on what you want to set.
+        """
+        if type_point not in ["co_points", "gcp2d"]:
+            raise ValueError(f"type_point {type_point} is incorrect,['co_points','gcp2d']")
+
+        for _, row in pd_mes.iterrows():
+            try:
+                getattr(self.shots[row['id_img']],
+                        type_point)[row['id_pt']] = np.array([row['column'], row['line']])
+            except KeyError:
+                continue
+
+    def get_point_world_dataframe(self, type_point: str, control_type: list) -> pd.DataFrame:
+        """
+        Retrieves id_pt, x, y, z in a pandas of the requested point type.
+
+        Args:
+            type_point (str): "co_points" or "gcp2d" depending on what you want to get.
+            control_type (list): Type controle for gcp.
+
+        Returns:
+            pandas: Pandas table.
+        """
+        if type_point not in ["co_points", "gcp2d"]:
+            raise ValueError(f"type_point {type_point} is incorrect,['co_points','gcp2d']")
+
+        out_pt, control_type = self.get_attr_transfo_pt(type_point, control_type)
+
+        id_pt = []
+        coor = []
+        for name_pt, coor_pt in getattr(self, out_pt).items():
+            if control_type and self.gcp3d[name_pt].code not in control_type:
+                continue
+            id_pt.append(name_pt)
+            coor.append(coor_pt)
+
+        coor = np.array(coor)
+        return pd.DataFrame({"id_pt": id_pt, "x": coor[:, 0], "y": coor[:, 1], "z": coor[:, 2]})
+
+    def set_point_world_dataframe(self, pd_mes: pd.DataFrame, type_point: str) -> None:
+        """
+        Set requested point type by pandas table id_pt, x, y, z.
+
+        Args:
+            pd_mes (pd): Pandas table of data.
+            type_point (str): "co_points" or "gcp2d" depending on what you want to set.
+        """
+        if type_point not in ["co_points", "gcp2d"]:
+            raise ValueError(f"type_point {type_point} is incorrect,['co_points','gcp2d']")
+
+        out_pt, _ = self.get_attr_transfo_pt(type_point, None)
+
+        if "type" not in list(pd_mes.columns):
+            for _, row in pd_mes.iterrows():
+                getattr(self, out_pt)[row['id_pt']] = np.array([row['x'], row['y'], row['z']])
+        else:
+            for _, row in pd_mes.iterrows():
+                self.add_gcp3d(row['id_pt'], row['type'], np.array([row['x'], row['y'], row['z']]))
+
+    def get_coor_pt_img_and_world(self, name_shot: str, type_point: str) -> tuple:
+        """
+        Recovers image and terrain data for all link points in the image.
+
+        Args:
+            name_shot (str): Name of shot to take.
+            type_point (str): Type point to take "co_points" or "gcp2d".
+
+        Returns:
+            tuple: np.array(obs_image), np.array(pt_world).
+        """
+        if type_point not in ['co_points', 'gcp2d']:
+            raise ValueError(f"type point {type_point} is incorrect.['co_points','gcp2d']")
+
+        out_pt, _ = self.get_attr_transfo_pt(type_point, None)
+
+        if not getattr(self, out_pt):
+            raise ValueError(f"Attribut {out_pt} in worksite is empty.")
+
+        co_point = getattr(self.shots[name_shot], type_point)
+        world_pt = []
+        img_pt = []
+        for key_pt, img_coor in co_point.items():
+            try:
+                pt_world = getattr(self, out_pt)[key_pt]
+                world_pt.append(pt_world)
+                img_pt.append(img_coor)
+            except KeyError:
+                print(f"Point {key_pt}, doesn't have world coordinate, perhaps a single point.")
+
+        return np.stack(img_pt, axis=-1), np.stack(world_pt, axis=-1)
+
+    def set_param_shot(self, approx=False) -> None:
+        """
+        Setting up different parameters in shot by data ressources.
+
+        Args:
+            approx (bool): True if you want to use approx euclidean system.
+        """
+        check_dtm = True
+        if not Dtm().path_dtm:
+            check_dtm = False
+
+        if not ProjEngine().geoid:
+            raise ValueError("you have not entered all the information required to set up"
+                             " the projection system. Because type z shot != type z data.")
+
+        self.approxeucli = approx
+        for shot in self.shots.values():
+            shot.set_param_eucli_shot(approx)
+            if check_dtm:
+                cam = self.cameras[shot.name_cam]
+                z_nadir = ImageWorldShot(shot, cam).image_to_world(np.array([cam.ppax, cam.ppay]),
+                                                                   self.type_z_shot,
+                                                                   self.type_z_shot, False)[2]
+                shot.set_z_nadir(z_nadir)
+
+    def set_unit_shot(self, type_z: str = None, unit_angle: str = None,
+                      linear_alteration: bool = None, order_axe: str = None) -> None:
+        """
+        Allows you to change unit or parameter of shots.
+
+        Args:
+            type_z (str): Unit of z shot you want.
+            unit_angle (str): Unit angle you want.
+            linear_alteration (bool): True if you want data corrected.
+            order_axe (str): Order of rotation matrice you want in your angle.
+        """
+        if unit_angle not in ["degree", "radian", None]:
+            raise ValueError(f"unit_angle: {unit_angle} is not recognized,"
+                             "recognized values are degree and radian.")
+
+        if type_z not in ["height", "altitude", None]:
+            raise ValueError(f"type_z: {type_z} is not recognized,"
+                             "recognized values are altitude and height.")
+
+        if type_z == self.type_z_shot:
+            type_z = None
+        else:
+            self.type_z_shot = type_z
+
+        for shot in self.shots.values():
+            if unit_angle is not None:
+                shot.set_unit_angle(unit_angle)
+            if type_z is not None:
+                shot.set_type_z(type_z)
+            if linear_alteration is not None:
+                shot.set_linear_alteration(linear_alteration)
+            if order_axe is not None:
+                shot.set_order_axe(order_axe)
+
+    def calculate_barycentre(self) -> np.ndarray:
+        """
+        Calculate barycentre of the worksite.
+
+        Returns:
+            np.array: The barycentre [X, Y, Z].
+        """
+        size = len(self.shots)
+        pos = np.zeros((size, 3))
+        i = 0
+        for shot in self.shots.values():
+            pos[i, :] = shot.pos_shot
+            i += 1
+        return np.mean(pos, axis=0)
+
+    def get_attr_transfo_pt(self, type_point: str, control_type: list) -> tuple:
+        """
+        Get string name of attribut where is save transformation image to world point.
+
+        Args:
+            type_point (str):"co_points" or "gcp2d"
+                              depending on what you want.
+            control_type (list): Type controle for gcp.
+        """
+        if type_point == 'co_points':
+            out_pt = "co_pts_world"
+            control_type = []
+        else:
+            out_pt = "gcp2d_in_world"
+
+        return out_pt, control_type

borea/writer/manage_writer.py

@@ -0,0 +1,23 @@
+"""
+Photogrammetry site file writer module.
+"""
+import importlib
+from borea.worksite.worksite import Worksite
+
+
+def manager_writer(writer: str, name: str, pathreturn: str, args: dict, work: Worksite) -> None:
+    """
+    Photogrammetric site file writing function.
+
+    Args:
+        writer (str): Output file format.
+        name (str): Name of the file.
+        pathreturn (str): Path to save the project.
+        args (dict): Other information for writing the file.
+        work (Worksite): The site to be recorded.
+    """
+    try:
+        my_module = importlib.import_module("borea.writer.writer_" + writer.lower())
+        work = my_module.write(name, pathreturn, args, work)
+    except ModuleNotFoundError as e:
+        raise ValueError(f"{writer} file is not taken into account !!!") from e

borea/writer/writer_con.py

@@ -0,0 +1,29 @@
+"""
+Photogrammetry worksite to writing in rpc.
+"""
+import os
+from pathlib import Path, PureWindowsPath
+from borea.worksite.worksite import Worksite
+from borea.geodesy.proj_engine import ProjEngine
+from borea.format.conl import Conl
+from borea.geodesy.projectionlist.search_proj import search_info
+
+
+def write(name: str, folder_con: str, param_con: dict, work: Worksite) -> None:
+    """
+    Converte Worksite in Conical class and save it in CON.
+
+    Args:
+        name (str): Name of file begin.
+        folder_con (str): Path of folder to registration file .CON.
+        param_con (dict): None.
+        work (Worksite): The site to be recorded.
+    """
+    _, _ = name, param_con
+    geoview_proj = search_info("EPSG", str(ProjEngine().epsg), "GEOVIEW")
+
+    for name_shot, shot in work.shots.items():
+        cam = work.cameras[shot.name_cam]
+        path_conical = os.path.join(Path(PureWindowsPath(folder_con)), f"{name_shot}.CON")
+
+        Conl(shot, cam, geoview_proj).save_conl(path_conical)

borea/writer/writer_df_to_txt.py

@@ -0,0 +1,32 @@
+"""
+Photogrammetry worksite to writing dataframe to txt.
+"""
+import os
+from pathlib import Path, PureWindowsPath
+import pandas as pd
+
+
+def write_df_to_txt(name: str, pathreturn: str, df: pd.DataFrame) -> None:
+    """
+    Writing DataFrame to txt in column.
+
+    Args:
+        name (str): Name of the file.
+        pathreturn (str): Path to save the file.
+        df (pd.DataFrame): DataFrame to save.
+    """
+    path_txt = os.path.join(Path(PureWindowsPath(pathreturn)), f"{name}.txt")
+
+    name_column = list(df.columns)
+
+    with open(path_txt, "w", encoding="utf-8") as file:
+        for _, row in df.iterrows():
+            wline = ""
+            for id_col in name_column:
+                if not isinstance(row[id_col], float):
+                    wline += f"{row[id_col]} "
+                else:
+                    wline += f"{round(row[id_col], 3)} "
+            wline += "\n"
+            file.write(wline)
+        file.close()

borea/writer/writer_opk.py

@@ -0,0 +1,70 @@
+"""
+Photogrammetry worksite to writing in opk.
+"""
+import os
+from pathlib import Path, PureWindowsPath
+import numpy as np
+from borea.worksite.worksite import Worksite
+from borea.utils.check.check_args_opk import check_header_file
+
+
+def write(name_opk: str, path_opk: str, args: dict, work: Worksite) -> None:
+    """
+    Write function, to save a photogrammetric site in .opk format.
+
+    Args:
+        name_opk (str): Name of the file writing.
+        path_opk (str): Path of folder to registration file .opk.
+        args (dict): Information for writing an opk file.
+                     keys:
+                     "order_axe" (str): Order of rotation matrix axes,
+                     "header" (list): List of column type file.
+                     "unit_angle" (str): Unit of angle 'degree' or 'radian'.
+                     "linear_alteration" (bool): True if data corrected by
+                     linear alteration.
+        work (Worksite): The site to be recorded.
+    """
+    path_opk = os.path.join(Path(PureWindowsPath(path_opk)), f"{name_opk}.opk")
+
+    if args["header"]:
+        header, type_z = check_header_file(args["header"])
+    else:
+        header = ['N', 'X', 'Y', 'Z', 'O', 'P', 'K', 'C']
+        type_z = work.type_z_shot
+
+    if "S" in header:
+        raise ValueError("Letter S doesn't existe in writing header opk.")
+
+    work.set_unit_shot(type_z, args["unit_angle"], args["linear_alteration"], args["order_axe"])
+
+    header_file = ""
+    for i in header:
+        header_file += i + "   "
+
+    try:
+        with open(path_opk, "w", encoding="utf-8") as file:
+            file.write(header_file)
+            file.write("\n")
+            keys = np.sort(list(work.shots))
+            line_writing = ""
+            for k in keys:
+                shot = work.shots[k]
+                dict_letter = {"N": shot.name_shot,
+                               "X": str(shot.pos_shot[0]),
+                               "Y": str(shot.pos_shot[1]),
+                               "Z": str(shot.pos_shot[2]),
+                               "O": str(shot.ori_shot[0]),
+                               "P": str(shot.ori_shot[1]),
+                               "K": str(shot.ori_shot[2]),
+                               "C": shot.name_cam}
+                for i in range(8):
+                    line_writing += dict_letter[header[i]]
+                    if i != 7:
+                        line_writing += "   "
+                    else:
+                        line_writing += "\n"
+
+            file.write(line_writing)
+        file.close()
+    except FileNotFoundError as e:
+        raise ValueError("The path doesn't exist !!!", e) from e