ign-borea 0.1.5__py3-none-any.whl

borea/reader/reader_point.py

@@ -0,0 +1,113 @@
+"""
+Script to read point (connecting point, gcp2d gcp3d) format
+.txt/.mes/.app with data arranged in columns.
+"""
+from pathlib import Path, PureWindowsPath
+import pandas as pd
+import numpy as np
+from borea.worksite.worksite import Worksite
+from borea.utils.check.check_args_reader_pt import check_header_file
+
+
+def read_file_pt(path: str, header: list, type_point: str, work: Worksite) -> None:
+    """
+    Read file of points.
+
+    Agrs:
+        file (str): Path of points file.
+        header (list): Header of file to read column.
+        type_point (str): Type of point is reading (co_point, gcp2d, gcp3d).
+        work (Worksite): Worksite which needs connecting points.
+    """
+    if type_point not in ["co_point", "gcp2d", "gcp3d"]:
+        raise ValueError(f"type {type_point} in incorrect. ['co_point', 'gcp2d', 'gcp3d']")
+
+    header, type_z = check_header_file(header, type_point)
+    work.type_z_data = type_z
+
+    try:
+        with open(Path(PureWindowsPath(path)), 'r', encoding="utf-8") as file_pts:
+            for pt in file_pts.readlines():
+                if pt != '\n' and pt[0] != '#':
+                    info = pt.split()
+
+                    if type_point == "gcp3d":
+                        coor = np.array([float(info[header.index("X")]),
+                                         float(info[header.index("Y")]),
+                                         float(info[header.index("Z")])])
+                        type_2args = "T"
+                    else:
+                        coor = np.array([float(info[header.index("X")]),
+                                         float(info[header.index("Y")])])
+                        type_2args = "N"
+
+                    try:
+                        getattr(work, "add_" + type_point)(info[header.index("P")],
+                                                           info[header.index(type_2args)],
+                                                           coor)
+                    except ValueError as e:
+                        raise ValueError("The letter T is missing "
+                                         "from the header of the file.") from e
+            file_pts.close()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"The path {path} is incorrect !!!") from e
+
+
+def read_file_pt_dataframe(path: str, header: list, type_point: str) -> pd.DataFrame:
+    """
+    Read file of points to save in Dataframe.
+
+    Agrs:
+        file (str): Path of points file.
+        header (list): Header of file to read column.
+        type_point (str): Type of point is reading (pt2d, pt3d).
+
+    Returns:
+        pd.Dataframe: Dataframe of data.
+    """
+    if type_point not in ["pt2d", "pt3d"]:
+        raise ValueError(f"type {type_point} in incorrect. ['pt2d', 'pt3d']")
+
+    header, _ = check_header_file(header, type_point)
+
+    id_pt = []
+    ttype = []
+    coor = []
+    try:
+        with open(Path(PureWindowsPath(path)), 'r', encoding="utf-8") as file_pts:
+            for pt in file_pts.readlines():
+                if pt != '\n' and pt[0] != '#':
+                    info = pt.split()
+
+                    if type_point == "pt3d":
+                        coor.append([float(info[header.index("X")]),
+                                     float(info[header.index("Y")]),
+                                     float(info[header.index("Z")])])
+                        type_2args = "T"
+                    else:
+                        coor.append([float(info[header.index("X")]),
+                                     float(info[header.index("Y")])])
+                        type_2args = "N"
+
+                    id_pt.append(info[header.index("P")])
+                    try:
+                        ttype.append(info[header.index(type_2args)])
+                    except ValueError:
+                        continue
+            file_pts.close()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"The path {path} is incorrect !!!") from e
+
+    coor = np.array(coor)
+    if type_point == "pt3d":
+        df = pd.DataFrame({"id_pt": id_pt,
+                           "type": ttype if ttype else None,
+                           "x": coor[:, 0],
+                           "y": coor[:, 1],
+                           "z": coor[:, 2]})
+    else:
+        df = pd.DataFrame({"id_pt": id_pt,
+                           "id_shot": ttype,
+                           "column": coor[:, 0],
+                           "line": coor[:, 1]})
+    return df

borea/stat/statistics.py

@@ -0,0 +1,215 @@
+"""
+Module for statistics
+"""
+import os
+import io
+from pathlib import Path, PureWindowsPath
+import numpy as np
+from borea.worksite.worksite import Worksite
+
+
+class Stat:
+    """
+    Calculates site statistics.
+    """
+    def __init__(self, work: Worksite, pathoutput: str, type_point: list = None) -> None:
+        """
+        Definition of the class Stat.
+
+        Args:
+            work (Worksite): The worksite to be treated.
+            pathoutput (str): Path to save the file.
+            type_point (list): List of type point on which we make the stats.
+        """
+        self.work = work
+        self.pathoutput = Path(PureWindowsPath(pathoutput))
+
+        if type_point is None:
+            self.type_point = []
+        else:
+            self.type_point = type_point
+
+        self.res_world_image = []
+        self.res_image_world = []
+        self.stat_world_image = {}
+        self.stat_image_world = {}
+
+    def main_stat_and_save(self) -> None:
+        """
+        Calculates and saves all site statistics.
+        """
+        self.main_stat_world_to_image()
+        self.main_stat_image_to_world()
+        self.save_stat_txt()
+
+    def main_stat_world_to_image(self) -> None:
+        """
+        Calculates residual and statistics on control point for world to image function.
+        """
+        self.stat_world_to_image()
+        if self.res_world_image:
+            self.stat_world_image = self.stat_list(self.res_world_image)
+
+    def main_stat_image_to_world(self) -> None:
+        """
+        Calculates residual and statistics on control point for image to world function.
+        """
+        self.stat_image_to_world()
+        if self.res_image_world:
+            self.stat_image_world = self.stat_list(self.res_image_world)
+
+    def stat_world_to_image(self) -> None:
+        """
+        Calculates residual of controle point for world to image.
+        residual = image's ground point - calculated image's ground point
+        """
+        for name_gcp, l_shot in self.work.gcp2d.items():
+            try:
+                if self.work.gcp3d[name_gcp].code in self.type_point or self.type_point == []:
+                    for shot in l_shot:
+                        try:
+                            img_coor = self.work.shots[shot].gcp2d[name_gcp]
+                            img_coor_calculated = self.work.shots[shot].gcp3d[name_gcp]
+                            l_data = [[name_gcp, shot], img_coor - img_coor_calculated]
+                            self.res_world_image.append(l_data)
+                        except KeyError:
+                            continue
+            except KeyError:
+                continue
+
+    def stat_image_to_world(self) -> None:
+        """
+        Calculates residual of controle point for image to world.
+        residual = ground control point - calculated ground control point
+        """
+        for name_gcp in list(self.work.gcp2d):
+            try:
+                if self.work.gcp3d[name_gcp].code in self.type_point or self.type_point == []:
+                    try:
+                        gcp_coor = self.work.gcp3d[name_gcp].coor
+                        gcp_coor_calculated = self.work.gcp2d_in_world[name_gcp]
+                        l_data = [[name_gcp], gcp_coor - gcp_coor_calculated]
+                        self.res_image_world.append(l_data)
+                    except KeyError:
+                        continue
+            except KeyError:
+                continue
+
+    def stat_list(self, data_list: list) -> dict:
+        """
+        Calculates statistics on residual data.
+        Min, Max, Median, Mean, Var, Sigma arithmetic and absolute.
+
+        Args:
+            data_list (list): List of data.
+        """
+        dict_output = {}
+        data = []
+        for ld in data_list:
+            data.append(ld[-1])
+        data = np.array(data)
+
+        list_stat1 = [[np.amin, np.amax], ["Min", "Max"], [np.argmin, np.argmax]]
+        list_stat2 = [[np.median, np.mean, np.var, np.std],
+                      ["Median", "Mean", "Var", "Sigma"]]
+
+        for func, name, argfunc in zip(list_stat1[0], list_stat1[1], list_stat1[2]):
+            pstat = []
+            abspstat = []
+            for i, j in zip(argfunc(data, axis=0), argfunc(abs(data), axis=0)):
+                if len(data_list[i][0]) == 1:
+                    pstat.append(data_list[i][0][0])
+                    abspstat.append(data_list[j][0][0])
+                else:
+                    pstat.append(data_list[i][0])
+                    abspstat.append(data_list[j][0])
+            dict_output[f"{name}_arith"] = {"val": func(data, axis=0), "data": pstat}
+            dict_output[f"{name}_abs"] = {"val": func(abs(data), axis=0), "data": abspstat}
+
+        for func, name in zip(list_stat2[0], list_stat2[1]):
+            dict_output[f"{name}_arith"] = np.round(func(data, axis=0), 2)
+            dict_output[f"{name}_abs"] = np.round(func(abs(data), axis=0), 2)
+
+        return dict_output
+
+    def save_stat_txt(self) -> None:
+        """
+        Save calculation statistics in a .txt file.
+        """
+        path_riw = os.path.join(self.pathoutput, f"Stat_residu_image_to_world_{self.work.name}.txt")
+        path_miw = os.path.join(self.pathoutput, f"Stat_metric_image_to_world_{self.work.name}.txt")
+        path_rwi = os.path.join(self.pathoutput, f"Stat_residu_world_to_image_{self.work.name}.txt")
+        path_mwi = os.path.join(self.pathoutput, f"Stat_metric_world_to_image_{self.work.name}.txt")
+
+        if self.res_image_world:
+            try:
+                with open(path_riw, "w", encoding="utf-8") as file_riw:
+                    file_riw.write("Control point statistics file.\n")
+                    file_riw.write("\n")
+                    file_riw.write("\n")
+                    file_riw.write("Residue of control points from image to terrain function.\n")
+                    file_riw.write("residual = ground control point -"
+                                   " calculated ground control point")
+                    file_riw.write("\n")
+                    file_riw.write("name_point  res_x  res_y  res_z\n")
+                    for data in self.res_image_world:
+                        file_riw.write(f"{data[0][0]}  {data[1][0]}  {data[1][1]}  {data[1][2]}\n")
+                    file_riw.close()
+            except FileNotFoundError as e:
+                raise ValueError("The path doesn't exist !!!") from e
+
+            with open(path_miw, "w", encoding="utf-8") as file_miw:
+                file_miw.write("Control point statistics file.\n")
+                file_miw.write("\n")
+                file_miw.write("\n")
+                file_miw.write("Statistics on residual function image to world.\n")
+                file_miw.write("Name_stat: [stat_X, stat_Y, stat_Z]\n")
+                self.write_stat(file_miw, self.stat_image_world)
+                file_miw.close()
+
+        if self.res_world_image:
+            with open(path_rwi, "w", encoding="utf-8") as file_rwi:
+                file_rwi.write("Control point statistics file.\n")
+                file_rwi.write("\n")
+                file_rwi.write("\n")
+                file_rwi.write("Residual control points from terrain to image function.\n")
+                file_rwi.write("residual = image's ground point - calculated image's ground point")
+                file_rwi.write("\n")
+                file_rwi.write("name_point  name_shot  res_column  res_line\n")
+                for data in self.res_world_image:
+                    file_rwi.write(f"{data[0][0]}  {data[0][1]}  {data[1][0]}  {data[1][1]}\n")
+                file_rwi.close()
+
+            with open(path_mwi, "w", encoding="utf-8") as file_mwi:
+                file_mwi.write("Control point statistics file.\n")
+                file_mwi.write("\n")
+                file_mwi.write("\n")
+                file_mwi.write("Statistics on residual function world to image.\n")
+                file_mwi.write("Name_stat: [stat_column, stat_line]\n")
+                self.write_stat(file_mwi, self.stat_world_image)
+                file_mwi.close()
+
+    def write_stat(self, file: io.TextIOWrapper, data: dict) -> None:
+        """
+        Write dictionary data statistics of the stat_list function on a file.
+
+        Args:
+            file (io.TextIOWrapper): File to write on.
+            data (dict): Dictionary on data statistics to stat_list.
+        """
+        file.write(f"Minimum_arithmetic: {data['Min_arith']['val']}\n")
+        file.write(f"Associated_point: {data['Min_arith']['data']}\n")
+        file.write(f"Minimum_absolute: {data['Min_abs']['val']}\n")
+        file.write(f"Associated_point: {data['Min_abs']['data']}\n")
+        file.write(f"Maximum_arithmetic: {data['Max_arith']['val']}\n")
+        file.write(f"Associated_point: {data['Max_arith']['data']}\n")
+        file.write(f"Maximum_absolute: {data['Max_abs']['val']}\n")
+        file.write(f"Associated_point: {data['Max_abs']['data']}\n")
+        file.write(f"Median_arithmetic: {data['Median_arith']}\n")
+        file.write(f"Median_absolute: {data['Median_abs']}\n")
+        file.write(f"Mean_arithmetic: {data['Mean_arith']}\n")
+        file.write(f"Mean_absolute: {data['Mean_abs']}\n")
+        file.write(f"Variance_arithmetic: {data['Var_arith']}\n")
+        file.write(f"Variance_absolute: {data['Var_abs']}\n")
+        file.write(f"Sigma_arithmetic: {data['Sigma_arith']}\n")
+        file.write(f"Sigma_absolute: {data['Sigma_abs']}\n")

borea/transform_world_image/transform_dtm/world_image_dtm.py

@@ -0,0 +1,47 @@
+"""
+World image transformation module for self
+"""
+import numpy as np
+
+
+class WorldImageDtm:
+    """
+    Function world_to_image and image_to_world for dtm.
+    Class parent of dtm.
+    """
+    def __init__(self, gt: tuple) -> None:
+        self.gt = gt
+
+    def image_to_world(self, coor_img: np.ndarray) -> np.ndarray:
+        """
+        Compute world coordinates from image coordinates.
+
+        Args:
+            coor_img (np.array): Coordinate image [column, line].
+
+        Returns:
+            np.array: x, y world coordinates.
+        """
+        if self.gt:
+            x = (np.array(coor_img[0])+0.5) * self.gt[1] + self.gt[0]
+            y = (np.array(coor_img[1])+0.5) * self.gt[5] + self.gt[3]
+        else:
+            x, y = np.nan, np.nan
+        return np.array([x, y])
+
+    def world_to_image(self, coor_world: np.ndarray) -> np.ndarray:
+        """
+        Compute image coordinates from world coordinates.
+
+        Args:
+            coor_world (np.array): Coordinate world 2D [X, Y].
+
+        Returns:
+            np.array: Image coordinates.
+        """
+        if self.gt:
+            col = (np.array(coor_world[0]) - self.gt[0])/self.gt[1] - 0.5
+            line = (np.array(coor_world[1]) - self.gt[3])/self.gt[5] - 0.5
+        else:
+            col, line = np.nan, np.nan
+        return np.array([col, line])

borea/transform_world_image/transform_shot/conversion_coor_shot.py

@@ -0,0 +1,58 @@
+"""
+Module to conversion z for WorldImageShot and ImageWorldShot
+"""
+import numpy as np
+from borea.datastruct.shot import Shot
+from borea.geodesy.proj_engine import ProjEngine
+
+
+def conv_z_shot_to_z_data(shot: Shot, type_z_shot: str, type_z_data: str,
+                          nonadir: bool = True, approx: bool = False) -> np.ndarray:
+    """
+    Convert type z shot to type z data. The Z of the object is NOT modified.
+
+    Args:
+        shot (Shot): Shot to process.
+        type_z_shot (str): Shot type z "altitude" or "height".
+        type_z_data (str): Data type z "altitude" or "height".
+        nonadir (bool): To calculate nadir no take linear alteration.
+
+    Returns:
+        np.array: Shot position coordinate with type z asking.
+    """
+    pos_shot = shot.pos_shot.copy()
+
+    if nonadir and shot.linear_alteration and not approx:
+        new_z = shot.get_z_remove_scale_factor()
+        pos_shot[2] = new_z
+
+    if type_z_shot != type_z_data:
+        if type_z_shot == "height":
+            new_z = ProjEngine().tranform_altitude(pos_shot)
+        else:
+            new_z = ProjEngine().tranform_height(pos_shot)
+        pos_shot[2] = new_z
+
+    return pos_shot
+
+
+def conv_output_z_type(coor: np.ndarray, type_z_input: str, type_z_output: str) -> np.ndarray:
+    """
+    Convert type z to the output given.
+
+    Args:
+        coor (Union[float, np.ndarray]): Coordinate [X, Y, Z].
+        type_z_input (str): Z type in input "height" or "altitude".
+        type_z_output (str): Z type in output "height" or "altitude".
+
+    Returns:
+        np.array: Coodinate x, y, z.
+    """
+    new_z = coor[2]
+    if type_z_input != type_z_output:
+        if type_z_input == "height":
+            new_z = ProjEngine().tranform_altitude(coor)
+        else:
+            new_z = ProjEngine().tranform_height(coor)
+
+    return np.array([coor[0], coor[1], new_z])

borea/transform_world_image/transform_shot/image_world_shot.py

@@ -0,0 +1,153 @@
+"""
+Image world transformation module for Shot
+"""
+import numpy as np
+from borea.datastruct.shot import Shot
+from borea.datastruct.camera import Camera
+from borea.datastruct.dtm import Dtm
+from borea.geodesy.proj_engine import ProjEngine
+from borea.transform_world_image.transform_shot.conversion_coor_shot import conv_z_shot_to_z_data
+from borea.transform_world_image.transform_shot.conversion_coor_shot import conv_output_z_type
+
+
+class ImageWorldShot():
+    """
+    Function image_to_world for shot.
+
+    Args:
+        shot (Shot): The shot for convert coordinate.
+        cam (Camera): The camera of the shot.
+    """
+    def __init__(self, shot: Shot, cam: Camera) -> None:
+        self.shot = shot
+        self.cam = cam
+
+    def image_to_world(self, img_coor: np.ndarray,
+                       type_z_data: str, type_z_shot: str,
+                       nonadir: bool = True) -> np.ndarray:
+        """
+        Calculate x and y cartographique coordinate with z.
+
+        Args:
+            img_coor (np.array): Image coordinate [col line].
+            type_z_data (str): Type of z data you want in output, "height" or "altitude".
+            type_z_shot (str): Type of z shot, "height" or "altitude".
+            nonadir (bool): To calculate nadir no take linear alteration.
+
+        Returns:
+            np.array: Cartographique coordinate [x,y,z].
+        """
+        if type_z_data != type_z_shot and not ProjEngine().geog_to_geoid:
+            raise ValueError("Missing geoid")
+
+        if not Dtm().path_dtm:
+            raise ValueError("Missing dtm")
+
+        img_coor = np.squeeze(img_coor)
+        coor_world = self.image_world_iter(img_coor, type_z_shot, nonadir)
+
+        coor_world = conv_output_z_type(coor_world, Dtm().type_dtm, type_z_data)
+
+        return coor_world
+
+    def image_world_iter(self, img_coor: np.ndarray,
+                         type_z_shot: str, nonadir: bool = True) -> np.ndarray:
+        """
+        Calculate x and y cartographique coordinate with z.
+
+        Args:
+            img_coor (np.array): Image coordinate [col line].
+            type_z_shot (str): Type of z shot, "height" or "altitude".
+            nonadir (bool): To calculate nadir no take linear alteration.
+
+        Returns:
+            np.array: Cartographique coordinate [x,y,z].
+        """
+        z_world = np.full_like(img_coor[0], Dtm().get_z_world(self.shot.pos_shot[0:2]))
+        coor_world = self.image_z_to_world(img_coor, type_z_shot, z_world, nonadir)
+        precision_reached = False
+        nbr_iter = 0
+        iter_max = 10
+        while not precision_reached and nbr_iter < iter_max:
+            z_world = np.squeeze(Dtm().get_z_world(coor_world[0:2]))
+            coor_new_world = self.image_z_to_world(img_coor, type_z_shot, z_world, nonadir)
+            x_diff = (coor_new_world[0] - coor_world[0]) ** 2
+            y_diff = (coor_new_world[1] - coor_world[1]) ** 2
+            z_diff = (coor_new_world[2] - coor_world[2]) ** 2
+            dist2 = x_diff + y_diff + z_diff
+            precision_reached = np.any(dist2 < 0.01**2)
+            coor_world = coor_new_world
+            nbr_iter += 1
+
+        return coor_world
+
+    def image_z_to_world(self, img_coor: np.ndarray, type_z_shot: str,
+                         z: np.ndarray = 0, nonadir: bool = True) -> np.ndarray:
+        """
+        Calculate x and y cartographique coordinate with z.
+
+        Args:
+            img_coor (np.array): Image coordinate [col line].
+            type_z_shot (str): Type of z "height" or "altitude".
+            z (Union[np.array, float]): La position z du point par défault = 0.
+            nonadir (bool): To calculate nadir no take linear alteration.
+
+        Returns:
+            np.array: Cartographique coordinate [x,y,z].
+        """
+        if isinstance(img_coor[0], np.ndarray):
+            if np.all(z == 0):
+                z = np.full_like(img_coor[0], 0)
+
+        pt_bundle = self.image_to_bundle(img_coor)
+
+        pos_shot_new_z = conv_z_shot_to_z_data(self.shot, type_z_shot, Dtm().type_dtm,
+                                               nonadir, self.shot.approxeucli)
+
+        pos_eucli = self.shot.projeucli.world_to_eucli(pos_shot_new_z)
+
+        pt_eucli = self.local_to_eucli(pt_bundle, pos_eucli, z)
+
+        pt_world = self.shot.projeucli.eucli_to_world(pt_eucli)
+        np.array([pt_world[0], pt_world[1], z])
+
+        return np.array([pt_world[0], pt_world[1], z])
+
+    def image_to_bundle(self, img_coor: np.ndarray) -> np.ndarray:
+        """
+        Convert coordinate image col line to coordinate bundle.
+
+        Args:
+            img_coor (np.array): Image coordinate [col line].
+
+        Returns:
+            np.array: Cartographique coordinate [x,y,z].
+        """
+        x_shot = img_coor[0] - self.cam.ppax
+        y_shot = img_coor[1] - self.cam.ppay
+        z_shot = np.full_like(x_shot, self.cam.focal)
+        x_shot, y_shot, z_shot = self.shot.f_sys_inv(x_shot, y_shot, z_shot)
+        x_bundle = x_shot / self.cam.focal * z_shot
+        y_bundle = y_shot / self.cam.focal * z_shot
+        z_bundle = z_shot
+        return np.array([x_bundle, y_bundle, z_bundle])
+
+    def local_to_eucli(self, pt_bundle: np.ndarray, pos_eucli: np.ndarray,
+                       z: np.ndarray) -> np.ndarray:
+        """
+        Convert coordinate point in local system to euclidean system.
+
+        Args:
+            pt_bundle (np.array): Point to convert [X, Y, Z].
+            pos_eucli (np.array): Shot position in the euclidean system.
+            z (np.array): Z position of points.
+
+        Returns:
+            np.array: [X, Y, Z] in euclidean system.
+        """
+        p_local = self.shot.mat_rot_eucli.T @ np.vstack(pt_bundle)
+        p_local = np.squeeze(p_local + pos_eucli.reshape((3, 1)))
+        lamb = (z - pos_eucli[2])/(p_local[2] - pos_eucli[2])
+        x_local = pos_eucli[0] + (p_local[0] - pos_eucli[0]) * lamb
+        y_local = pos_eucli[1] + (p_local[1] - pos_eucli[1]) * lamb
+        return np.array([x_local, y_local, z])