ign-borea 0.1.5__py3-none-any.whl

borea/transform_world_image/transform_shot/world_image_shot.py

@@ -0,0 +1,117 @@
+"""
+World image 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
+
+
+class WorldImageShot():
+    """
+    Function world_to_image 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 world_to_image(self, coor_world: np.ndarray,
+                       type_z_data: str, type_z_shot: str) -> np.ndarray:
+        """
+        Calculates the c,l coordinates of a terrain point in an image.
+
+        Args:
+            coor_world (np.array): The coordinate [x, y, z] of ground point.
+            type_z_data (str): Type of z of data, "height" or "altitude".
+            type_z_shot (str): Type of z of worksite, "height" or "altitude".
+
+        Returns:
+            np.array: The image coordinate [c,l].
+        """
+        if type_z_data != type_z_shot and not ProjEngine().geog_to_geoid:
+            raise ValueError("Missing geoid")
+
+        if self.shot.linear_alteration and not Dtm().path_dtm and not self.shot.approxeucli:
+            raise ValueError("Missing dtm")
+
+        if self.shot.approxeucli and not self.shot.linear_alteration:
+            raise ValueError("The data are not corrected by linear alteration "
+                             "and you are using an approximate system.")
+
+        p_eucli = self.shot.projeucli.world_to_eucli(coor_world)
+
+        # Convert coordinate in bundle system to image system
+        coor_image = self.eucli_to_image(p_eucli, type_z_data, type_z_shot)
+
+        return coor_image
+
+    def eucli_to_image(self, p_eucli: np.ndarray,
+                       type_z_data: str, type_z_shot: str) -> np.ndarray:
+        """
+        Convert euclidean coordinate to image coordinate.
+
+        Args:
+            p_eucli (np.array): The euclidean coordinate [x, y, z] of ground point.
+            type_z_data (str): Type of z of data, "height" or "altitude".
+            type_z_shot (str): Type of z of worksite, "height" or "altitude".
+
+        Returns:
+            np.array: Bundle coordinate [c,l].
+        """
+        # Convert euclidean coordinate system to bundle system
+        p_bundle = self.eucli_to_bundle(p_eucli, type_z_data, type_z_shot)
+
+        # Convert coordinate in bundle system to image system
+        x_col, y_line = self.bundle_to_image(p_bundle)
+
+        return np.array([x_col, y_line])
+
+    def eucli_to_bundle(self, p_eucli: np.ndarray,
+                        type_z_data: str, type_z_shot: str) -> np.ndarray:
+        """
+        Convert euclidean coordinate to bundle coordinate.
+
+        Args:
+            p_eucli (np.array): The euclidean coordinate [x, y, z] of ground point.
+            type_z_data (str): Type of z of data, "height" or "altitude".
+            type_z_shot (str): Type of z of worksite, "height" or "altitude".
+
+        Returns:
+            np.array: Bundle coordinate [c,l].
+        """
+        pos_shot_new_z = conv_z_shot_to_z_data(self.shot, type_z_shot, type_z_data,
+                                               approx=self.shot.approxeucli)
+
+        # Convert coordinate in world system to euclidean system
+        pos_eucli = self.shot.projeucli.world_to_eucli(pos_shot_new_z)
+
+        # Convert coordinate in euclidean system to bundle system
+        p_bundle = np.squeeze((self.shot.mat_rot_eucli @ np.vstack([p_eucli[0] - pos_eucli[0],
+                                                                    p_eucli[1] - pos_eucli[1],
+                                                                    p_eucli[2] - pos_eucli[2]])))
+        return p_bundle
+
+    def bundle_to_image(self, p_bundle: np.ndarray) -> np.ndarray:
+        """
+        Convert coordinate bundle to coordinate image col line.
+
+        Args:
+            p_bundle (np.array): [X, Y, Z] coordinates in bundle.
+
+        Returns:
+            np.array: Image coordinate x_col y_line.
+        """
+        x_shot = p_bundle[0] * self.cam.focal / p_bundle[2]
+        y_shot = p_bundle[1] * self.cam.focal / p_bundle[2]
+        z_shot = p_bundle[2]
+        x_shot, y_shot, z_shot = self.shot.f_sys(x_shot, y_shot, z_shot)
+        x_col = self.cam.ppax + x_shot
+        y_line = self.cam.ppay + y_shot
+
+        return np.array([x_col, y_line])

borea/transform_world_image/transform_worksite/image_world_intersection.py

@@ -0,0 +1,154 @@
+"""
+Class to calcule world coordinate by intersection.
+"""
+from dataclasses import dataclass
+import numpy as np
+from borea.worksite.worksite import Worksite
+from borea.datastruct.shot import Shot
+from borea.geodesy.local_euclidean_proj import LocalEuclideanProj
+from borea.geodesy.approx_euclidean_proj import ApproxEuclideanProj
+from borea.transform_world_image.transform_shot.conversion_coor_shot import conv_z_shot_to_z_data
+from borea.transform_world_image.transform_shot.image_world_shot import ImageWorldShot
+
+
+@dataclass
+class WorldIntersection:
+    """
+    Class to calculate image coordinate to world coordinate in worksite by intersect bundle.
+
+    Args:
+        name (str): Name of the worksite.
+    """
+    work: Worksite
+
+    def calculate_image_world_by_intersection(self, type_point: str,
+                                              control_type: list = None) -> None:
+        """
+        Calculates the ground position of connecting point by intersection with
+        the most distance between two shots or ground image point.
+
+        Args:
+            type_point (str): "co_points" or "gcp2d"
+                              depending on what you want to calculate.
+            control_type (list): Type controle for gcp.
+        """
+
+        out_pt, control_type = self.work.get_attr_transfo_pt(type_point, control_type)
+
+        for name_pt, list_shot in getattr(self.work, type_point).items():  # Loop on points
+            try:
+                if control_type != [] and self.work.gcp3d[name_pt].code not in control_type:
+                    continue
+            except KeyError:
+                continue
+            if len(list_shot) == 1:
+                continue
+
+            coor = self.comput_inter_in_2_more_distant_shot(name_pt, list_shot)
+
+            getattr(self.work, out_pt)[name_pt] = coor
+
+    def comput_inter_in_2_more_distant_shot(self, name_pt: str, list_shot: list) -> np.ndarray:
+        """
+        Search for the two most distant images where the point is visible,
+        to calculate the point's position.
+
+        Args:
+            name_pt (str): Name of the point.
+            list_shot (list): List of name shot where the point is visible.
+
+        Returns:
+            np.ndarray: World coordinate of the point.
+        """
+        shot1 = ""
+        shot2 = ""
+        dist = 0
+        list_shot1 = list_shot.copy()
+        list_shot2 = list_shot1.copy()
+        _ = list_shot1.pop(-1)
+        for name_shot1 in list_shot1:  # Double loop on shots where see the point
+            _ = list_shot2.pop(0)
+            for name_shot2 in list_shot2:
+                pos_shot1 = self.work.shots[name_shot1].pos_shot
+                pos_shot2 = self.work.shots[name_shot2].pos_shot
+                new_dist = np.sqrt(np.sum((pos_shot1 - pos_shot2)**2))
+                if new_dist > dist:
+                    dist = new_dist
+                    shot1 = name_shot1
+                    shot2 = name_shot2
+        return self.intersection_pt_in_2shot(name_pt,
+                                             self.work.shots[shot1],
+                                             self.work.shots[shot2])
+
+    def intersection_pt_in_2shot(self, name_point: str, shot1: Shot, shot2: Shot) -> np.ndarray:
+        """
+        Calculates the euclidien position of a point from two shots.
+
+        Args:
+            name_point (str): Name of copoint to calcule coordinate.
+            shot1 (Shot): Frist shot.
+            shot2 (Shot): Second shot.
+
+        Returns:
+            np.array: Euclidien coordinate of the copoint.
+        """
+        # Retrieve coordinates of points in the image.
+        if name_point in list(shot1.co_points):
+            p_img1 = shot1.co_points[name_point]
+            p_img2 = shot2.co_points[name_point]
+        else:
+            p_img1 = shot1.gcp2d[name_point]
+            p_img2 = shot2.gcp2d[name_point]
+
+        # Setting up a Euclidean projection centered on the two images.
+        bary = (shot1.pos_shot + shot2.pos_shot)/2
+        if shot1.approxeucli:
+            projeucli = ApproxEuclideanProj(bary[0], bary[1])
+        else:
+            projeucli = LocalEuclideanProj(bary[0], bary[1])
+
+        # Calculates data specific to Euclidean projection.
+        mat_eucli1 = projeucli.mat_to_mat_eucli(shot1.pos_shot[0], shot1.pos_shot[1], shot1.mat_rot)
+        mat_eucli2 = projeucli.mat_to_mat_eucli(shot2.pos_shot[0], shot2.pos_shot[1], shot2.mat_rot)
+        pos_eucli1 = conv_z_shot_to_z_data(shot1, self.work.type_z_shot, self.work.type_z_data)
+        pos_eucli2 = conv_z_shot_to_z_data(shot2, self.work.type_z_shot, self.work.type_z_data)
+        pos_eucli1 = projeucli.world_to_eucli(pos_eucli1)
+        pos_eucli2 = projeucli.world_to_eucli(pos_eucli2)
+
+        # Calculates the director vectors of the point bundles in the Euclidean reference system.
+        vect1 = mat_eucli1.T @ ImageWorldShot(shot1, self.work.cameras[shot1.name_cam]
+                                              ).image_to_bundle(p_img1)
+        vect2 = mat_eucli2.T @ ImageWorldShot(shot2, self.work.cameras[shot2.name_cam]
+                                              ).image_to_bundle(p_img2)
+
+        # Calculating the intersection of two lines
+        pt_inter = self.intersection_line_3d(vect1, pos_eucli1, vect2, pos_eucli2)
+
+        # Converting the point to the world system.
+        pt_inter = projeucli.eucli_to_world(pt_inter)
+        return pt_inter
+
+    def intersection_line_3d(self, vect1: np.ndarray, point1: np.ndarray,
+                             vect2: np.ndarray, point2: np.ndarray) -> np.ndarray:
+        """
+        Calculation of the intersection point between 2 line in a 3d system.
+
+        Args:
+            vect1 (np.array): Directing vector of the first line.
+            point1 (np.array): A point on the first line.
+            vect2 (np.array): Directing vector of the second line.
+            point2 (np.array): A point on the second line.
+
+        Returns:
+            np.array: The point of the intersection of the lines.
+        """
+        base = point2 - point1
+        norme_v1 = vect1 @ vect1
+        norme_v2 = vect2 @ vect2
+        v1_v2 = vect1 @ vect2
+        b_v1 = base @ vect1
+        b_v2 = base @ vect2
+        denum = v1_v2**2 - norme_v1*norme_v2
+        p1_eucli = point1 + ((b_v2*v1_v2 - b_v1*norme_v2)/(denum))*vect1
+        p2_eucli = point2 + ((b_v2*norme_v1 - b_v1*v1_v2)/(denum))*vect2
+        return (p1_eucli + p2_eucli) / 2

borea/transform_world_image/transform_worksite/image_world_least_square.py

@@ -0,0 +1,184 @@
+"""
+Class to calcule world coordinate by least square methode.
+"""
+from dataclasses import dataclass
+import numpy as np
+import pandas as pd
+from scipy.sparse import coo_matrix
+from borea.worksite.worksite import Worksite
+from borea.geodesy.local_euclidean_proj import LocalEuclideanProj
+from borea.geodesy.approx_euclidean_proj import ApproxEuclideanProj
+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.sparse import invert_diag_sparse_matrix_3_3
+from borea.utils.miscellaneous.param_bundle import set_param_bundle_diff
+
+
+@dataclass
+class WorldLeastSquare:
+    """
+    Class to calculate image coordinate to world coordinate in worksite by least square.
+
+    Args:
+        name (str): Name of the worksite.
+    """
+    work: Worksite
+
+    def compute_image_world_least_square(self, type_point: str, control_type: list) -> None:
+        """
+        Calculates the mean of the result x y z of the point for each shot where it's visible.
+
+        Args:
+            type_point (str): "co_points" or "gcp2d"
+                              depending on what you want to calculate.
+            control_type (list): List of code gcp to take.
+                                 To take all points or co_point, control_type = [].
+        """
+        # Creation of worksite's barycentre.
+        bary = self.work.calculate_barycentre()
+        if self.work.approxeucli:
+            eucliproj = ApproxEuclideanProj(bary[0], bary[1])
+        else:
+            eucliproj = LocalEuclideanProj(bary[0], bary[1])
+
+        # Retrieving point data from images.
+        pd_mes = self.work.get_point_image_dataframe(type_point, control_type)
+        pd_mes = pd_mes[pd_mes.duplicated(subset=['id_pt'], keep=False)]
+
+        # Initialization of euclidean points.
+        pd_pnt = self.init_eucli_points(pd_mes)
+
+        # Do least square methode.
+        pd_pnt = self.least_square_intersect(pd_mes, pd_pnt)
+
+        # Transform euclidean point to world point.
+        xw, yw, zw = eucliproj.eucli_to_world(np.array([pd_pnt["x"].to_numpy(),
+                                                        pd_pnt["y"].to_numpy(),
+                                                        pd_pnt["z"].to_numpy()]))
+        pd_pnt["x"] = xw
+        pd_pnt["y"] = yw
+        pd_pnt["z"] = zw
+        self.work.set_point_world_dataframe(pd_pnt, type_point)
+
+    def init_eucli_points(self, pd_mes: pd.DataFrame) -> pd.DataFrame:
+        """
+        Initialization of ground points.
+
+        Args:
+            pd_mes (pd.Dataframe): Dataframe of image data, id_pt, id_img; column, line.
+
+        Returns:
+            pd.Dataframe: Dataframe of eucli data, id_pt, x, y, z.
+        """
+        pb_pnt_unique = pd_mes[~pd_mes['id_pt'].duplicated(keep='first')]
+        group = pb_pnt_unique.groupby('id_img')
+        frames = []
+
+        for _, (id_shot, pd_mes_pnt) in enumerate(group):
+            shot = self.work.shots[id_shot]
+            cam = self.work.cameras[shot.name_cam]
+            coor_img = np.array([pd_mes_pnt["column"].to_numpy(), pd_mes_pnt["line"].to_numpy()])
+            z_world = np.squeeze(np.full(pd_mes_pnt.shape[0], Dtm().get_z_world(shot.pos_shot[:2])))
+
+            # Calculation of world coordinate for all points in this shot
+            coor_world = ImageWorldShot(shot, cam).image_z_to_world(coor_img,
+                                                                    self.work.type_z_shot,
+                                                                    z_world)
+
+            # Transform of world coordinate to euclidean coordinate
+            coor_eucli = shot.projeucli.world_to_eucli(coor_world)
+            frames += [pd.DataFrame({"id_pt": pd_mes_pnt["id_pt"],
+                                     "x": coor_eucli[0],
+                                     "y": coor_eucli[1],
+                                     "z": coor_eucli[2]})]
+
+        pd_pnt = pd.concat(frames, ignore_index=True)
+        pd_pnt["index_pnt"] = pd_pnt.index
+
+        return pd_pnt
+
+    def least_square_intersect(self, pd_mes: pd.DataFrame, pd_pnt: pd.DataFrame) -> pd.DataFrame:
+        """
+        Methode of least square to calcule world coordinate point.
+
+        Args:
+            pd_mes (pd.Dataframe): Dataframe of image data, id_pt, id_img; column, line.
+            pd_pnt (pd.Dataframe): Dataframe of world data, id_pt, x, y, z.
+
+        Returns:
+            pd.Dataframe: Field data converged.
+        """
+        # Initialzsation number of observation
+        nbr_obs = pd_mes.shape[0] * 2
+        nbr_inc = pd_mes.nunique(axis=0)["id_pt"] * 3
+
+        dx = 1.01
+        nbr_iter = 0
+        while not np.all(abs(dx) < 0.01) and nbr_iter < 5:
+            # join data
+            pd_mes_temp = pd_mes.join(pd_pnt.set_index('id_pt'), on="id_pt")
+            pd_mes_temp = pd_mes_temp.sort_values(by=["index_pnt"]).reset_index(drop=True)
+            pd_mes_temp["index_mes"] = pd_mes_temp.index
+
+            mat_a, v_res = self.create_mat_a_and_vect_residu(pd_mes_temp, nbr_obs, nbr_inc)
+
+            # Solving the system by inverting the block diagonal matrix
+            dx = invert_diag_sparse_matrix_3_3(mat_a.T @ mat_a) @ mat_a.T @ v_res
+
+            # Update World coordinate
+            pd_pnt["x"] += dx[0::3]
+            pd_pnt["y"] += dx[1::3]
+            pd_pnt["z"] += dx[2::3]
+
+            nbr_iter += 1
+
+        return pd_pnt
+
+    def create_mat_a_and_vect_residu(self, pd_mes_temp: pd.DataFrame,
+                                     nbr_obs: int, nbr_inc: int) -> tuple:
+        """
+        Creation of matrix A and vector residu for the least square methode.
+
+        Args:
+            pd_mes_temp (pd.Dataframe): Dataframe of data.
+            nbr_obs (int): Number of image observation.
+            nbr_inc (int): Number of world observation.
+
+        Returns:
+            tuple: Matrix A and vector residu.
+        """
+        v_res = np.zeros(nbr_obs)
+        coord_i, coord_j, data = [], [], []
+        for _, (id_shot, pd_data) in enumerate(pd_mes_temp.groupby('id_img')):
+            shot = self.work.shots[id_shot]
+            cam = self.work.cameras[shot.name_cam]
+
+            pti = WorldImageShot(shot, cam).eucli_to_image(np.array([pd_data["x"].to_numpy(),
+                                                                     pd_data["y"].to_numpy(),
+                                                                     pd_data["z"].to_numpy()]),
+                                                           self.work.type_z_data,
+                                                           self.work.type_z_shot)
+
+            _, vect_u, mat_v = set_param_bundle_diff(shot,
+                                                     np.array([pd_data["x"].to_numpy(),
+                                                               pd_data["y"].to_numpy(),
+                                                               pd_data["z"].to_numpy()]))
+
+            coord_i += [np.repeat(2 * pd_data['index_mes'].to_numpy(), 6) +
+                        np.tile([0, 0, 0, 1, 1, 1], len(pd_data["x"].to_numpy()))]
+            coord_j += [np.repeat(3 * pd_data['index_pnt'].to_numpy(), 6) +
+                        np.tile([0, 1, 2, 0, 1, 2], len(pd_data["y"].to_numpy()))]
+
+            data += [(np.tile(np.repeat(cam.focal / vect_u[2]**2, 2), (3, 1)).T *
+                      mat_v @ shot.mat_rot_eucli).flatten()]
+
+            v_res[2 * pd_data['index_mes'].to_numpy()] = pd_data["column"].to_numpy() - pti[0]
+            v_res[2 * pd_data['index_mes'].to_numpy() + 1] = pd_data["line"].to_numpy() - pti[1]
+
+        # Creation matrix
+        coord_i = np.concatenate(coord_i)
+        coord_j = np.concatenate(coord_j)
+        data = np.concatenate(data)
+
+        return coo_matrix((data, (coord_i, coord_j)), shape=(nbr_obs, nbr_inc)).tocsr(), v_res

borea/transform_world_image/transform_worksite/image_world_work.py

@@ -0,0 +1,49 @@
+"""
+Image world transformation module for worksite
+"""
+from dataclasses import dataclass
+from borea.worksite.worksite import Worksite
+# pylint: disable-next=line-too-long
+from borea.transform_world_image.transform_worksite.image_world_intersection import WorldIntersection  # noqa: E501
+from borea.transform_world_image.transform_worksite.image_world_least_square import WorldLeastSquare
+
+
+@dataclass
+class ImageWorldWork:
+    """
+    Class to calculate image coordinate to world coordinate in worksite.
+
+    Args:
+        name (str): Name of the worksite.
+    """
+    work: Worksite
+
+    def manage_image_world(self, type_point: str = "co_points", type_process: str = "inter",
+                           control_type: list = None) -> None:
+        """
+        Process to calcule image coordinate to world coordinate.
+
+        Args:
+            type_point (str): "co_points" or "gcp2d"
+                              depending on what you want to calculate.
+            type_process (str): Type of process you want to use.
+                                * "inter" by intersect bundle of point in each shot.
+                                * "square" take all point and do methode least square.
+            control_type (list): Type controle for gcp.
+        """
+        if type_point not in ["co_points", "gcp2d"]:
+            raise ValueError(f"type_point {type_point} is incorrect,['co_points','gcp2d']")
+
+        if type_process not in ["inter", "square"]:
+            raise ValueError(f"type_process {type_process} is incorrect, "
+                             "['inter','square']")
+
+        if control_type is None or type_point == "co_points":
+            control_type = []
+
+        if type_process == "inter":
+            WorldIntersection(self.work).calculate_image_world_by_intersection(type_point,
+                                                                               control_type)
+
+        if type_process == "square":
+            WorldLeastSquare(self.work).compute_image_world_least_square(type_point, control_type)