cars 1.0.0rc1__cp313-cp313-musllinux_1_2_i686.whl

cars/data_structures/cars_dict.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""
+cars_dict module:
+
+"""
+
+
+class CarsDict:
+    """
+    CarsDict.
+
+    Internal CARS structure for dict representation
+    """
+
+    def __init__(self, dict_data, attributes=None):
+        """
+        Init function of CarsDict.
+        If a path is provided, restore CarsDataset saved on disk.
+
+        :param dict_data: dictrionary to store
+        :type dict_data: dict
+        :param attributes: attributes
+        :type attributes: dict
+
+        """
+
+        self.data = dict_data
+        self.attrs = attributes
+        if self.attrs is None:
+            self.attrs = {}
+
+    def __repr__(self):
+        """
+        Repr function
+        :return: printable self CarsDataset
+        """
+        return self.custom_print()
+
+    def __str__(self):
+        """
+        Str function
+        :return: printable self CarsDataset
+        """
+        return self.custom_print()
+
+    def custom_print(self):
+        """
+        Return string of self
+        :return: printable self
+        """
+
+        res = str(self.__class__) + ":  \n" "data: " + str(
+            self.data
+        ) + "\n" + "attrs: " + str(self.attrs)
+        return res

cars/data_structures/corresponding_tiles_tools.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""
+Contains functions for array reconstructions and crop for multiple tiles
+"""
+
+
+# Third party imports
+import numpy as np
+import xarray as xr
+
+
+def reconstruct_data(tiles, window, overlap):  # noqa: C901
+    """
+    Combine list of tiles (window, overlap, xr.Dataset) as
+    one full dataset
+
+    :param tiles: list of tiles
+    :type tiles: list(tuple)
+    :param window: window of base tile [row min, row max, col min col max]
+    :type window: list
+    :param overlap: overlap of base tile [row min, row max, col min col max]
+    :type overlap: list
+
+    :return: full dataset, row min of combined, col min of combined
+    :rtype: xr.Dataset, int, int
+
+    """
+
+    first_valid_tile = next(
+        (tile for tile in tiles if tile[2] is not None), None
+    )
+
+    if first_valid_tile is None:
+        return None, None, None
+
+    list_tags = list(first_valid_tile[2].keys())
+
+    row_min, row_max, col_min, col_max = window
+    ol_row_min, ol_row_max, ol_col_min, ol_col_max = overlap
+
+    # find whole window and new overlaps
+    for tile_window, tile_overlap, _ in tiles:
+        if tile_window[0] < row_min:
+            row_min, ol_row_min = tile_window[0], tile_overlap[0]
+        if tile_window[1] > row_max:
+            row_max, ol_row_max = tile_window[1], tile_overlap[1]
+        if tile_window[2] < col_min:
+            col_min, ol_col_min = tile_window[2], tile_overlap[2]
+        if tile_window[3] > col_max:
+            col_max, ol_col_max = tile_window[3], tile_overlap[3]
+
+    # Generate new arr
+
+    # Compute full shape
+    nb_rows = int(row_max + ol_row_max - (row_min - ol_row_min))
+    nb_cols = int(col_max + ol_col_max - (col_min - ol_col_min))
+
+    new_coords = {}
+    for key in first_valid_tile[2].coords.keys():
+        if key == "row":
+            new_coords["row"] = range(
+                int(row_min - ol_row_min), int(row_max + ol_row_max)
+            )
+        elif key == "col":
+            new_coords["col"] = range(
+                int(col_min - ol_col_min), int(col_max + ol_col_max)
+            )
+        elif key == "y":
+            # Doesnt contain  coordinates, but pixels position
+            # after reconstruction, only used in notebooks
+            new_coords["y"] = range(
+                int(row_min - ol_row_min), int(row_max + ol_row_max)
+            )
+        elif key == "x":
+            # Doesnt contain  coordinates, but pixels position
+            # after reconstruction, only used in notebooks
+            new_coords["x"] = range(
+                int(col_min - ol_col_min), int(col_max + ol_col_max)
+            )
+        else:
+            new_coords[key] = first_valid_tile[2].coords[key]
+
+    new_dataset = xr.Dataset(data_vars={}, coords=new_coords)
+
+    for tag in list_tags:
+        # reconstruct data
+        data_type = first_valid_tile[2][tag].dtype
+        data_shape = (nb_rows, nb_cols)
+        dims = first_valid_tile[2][tag].dims
+        if len(dims) == 3:
+            nb_bands = first_valid_tile[2][tag].values.shape[0]
+            data_shape = (nb_bands, nb_rows, nb_cols)
+        data = np.nan * np.zeros(data_shape)
+
+        for tile_window, tile_overlap, tile_ds in tiles:
+            # only use overlaps when on the border of full image
+            # row min
+            if row_min == tile_window[0]:
+                # is on border -> use overlap
+                real_row_min = int(tile_window[0])
+                getter_offset_row_min = int(0)
+            else:
+                real_row_min = int(tile_window[0] + ol_row_min)
+                getter_offset_row_min = int(tile_overlap[0])
+
+            # row max
+            if row_max == tile_window[1]:
+                # is on border -> use overlap
+                real_row_max = int(tile_window[1] + ol_row_max + ol_row_min)
+                getter_offset_row_max = int(0)
+            else:
+                real_row_max = int(tile_window[1] + ol_row_min)
+                getter_offset_row_max = int(tile_overlap[1])
+
+            # col min
+            if col_min == tile_window[2]:
+                # is on border -> use overlap
+                real_col_min = int(tile_window[2])
+                getter_offset_col_min = int(0)
+            else:
+                real_col_min = int(tile_window[2] + ol_col_min)
+                getter_offset_col_min = int(tile_overlap[2])
+
+            # col max
+            if col_max == tile_window[3]:
+                # is on border -> use overlap
+                real_col_max = int(tile_window[3] + ol_col_max + ol_col_min)
+                getter_offset_col_max = int(0)
+            else:
+                real_col_max = int(tile_window[3] + ol_col_min)
+                getter_offset_col_max = int(tile_overlap[3])
+
+            real_row_min = int(real_row_min - row_min)
+            real_row_max = int(real_row_max - row_min)
+            real_col_min = int(real_col_min - col_min)
+            real_col_max = int(real_col_max - col_min)
+
+            # Fill data
+            if tile_ds is not None:
+                tile_data = tile_ds[tag].values
+
+                if len(tile_data.shape) == 2:
+                    data[
+                        real_row_min:real_row_max, real_col_min:real_col_max
+                    ] = tile_data[
+                        getter_offset_row_min : tile_data.shape[0]
+                        - getter_offset_row_max,
+                        getter_offset_col_min : tile_data.shape[1]
+                        - getter_offset_col_max,
+                    ]
+                else:
+                    data[
+                        :, real_row_min:real_row_max, real_col_min:real_col_max
+                    ] = tile_data[
+                        :,
+                        getter_offset_row_min : tile_data.shape[1]
+                        - getter_offset_row_max,
+                        getter_offset_col_min : tile_data.shape[2]
+                        - getter_offset_col_max,
+                    ]
+
+        # add arrays to data
+        new_dataset[tag] = xr.DataArray(
+            data,
+            dims=dims,
+        ).astype(data_type)
+    return new_dataset, row_min - ol_row_min, col_min - ol_col_min

cars/data_structures/dataframe_converter.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+# coding: utf8
+#
+# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
+#
+# This file is part of CARS
+# (see https://github.com/CNES/cars).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""
+Contains function to convert the point cloud dataframe to laz format:
+"""
+import logging
+import warnings
+
+import laspy
+import laspy.file
+import laspy.header
+import numpy as np
+from pyproj import CRS
+
+import cars.core.constants as cst
+
+
+def convert_pcl_to_laz(point_clouds, output_filename: str):
+    """
+    Convert 3d point cloud to laz format
+    :param point_clouds: point_clouds dataframe
+    :param output_filename: output laz filename (with naming convention)
+    :return: the list of point cloud save in las format
+    """
+
+    # get all layer : X, Y, Z and color
+    coordinates = ["X", "Y", "Z"]
+    las_color = ["red", "green", "blue"]
+    color_type = point_clouds.attrs["attributes"]["color_type"]
+    epsg = point_clouds.attrs["attributes"]["epsg"]
+    input_color = get_input_color(point_clouds)
+    laz_file_name = output_filename
+    arrays_pcl, arrays_color = extract_point_cloud(
+        point_clouds, coordinates, input_color, color_type
+    )
+    # generate laz
+    generate_laz(
+        laz_file_name, coordinates, las_color, arrays_pcl, arrays_color
+    )
+    # dump prj file
+    generate_prj_file(laz_file_name, epsg)
+
+
+def get_input_color(point_clouds):
+    """
+    Retrieve color index from point cloud
+    :param point_clouds: point clouds data
+    :return: input color list
+    """
+
+    input_color = ["color_R", "color_G", "color_B"]
+    color_names = [
+        name
+        for name in point_clouds.columns
+        if cst.POINT_CLOUD_CLR_KEY_ROOT in name
+    ]
+    nb_color = len(color_names)
+    if nb_color == 1:
+        logging.warning("No color available for point cloud")
+        input_color = color_names
+    elif sorted(color_names[:3]) != sorted(input_color):
+        logging.warning(
+            "Descriptions of color bands {} does not conform to names "
+            "'R', 'G', 'B'".format(color_names[:3])
+        )
+        input_color = color_names[:3]
+
+    return input_color
+
+
+def extract_point_cloud(point_clouds, coordinates, input_color, color_type):
+    """
+    Extract point cloud positions (x,y,z) and color layers
+    :param point_clouds: point cloud dataframe
+    :param coordinate: target coordinates key index
+    :param input_color: color key index according to input
+    :param color_type: type of color data
+    :param nb
+    :return: point cloud array location and color
+    """
+
+    nb_color = len(input_color)
+    arrays_pcl = None
+    arrays_color = None
+    for name in point_clouds.columns:
+        # get coordinates bands
+        if name in ["x", "y", "z"]:
+            array = point_clouds[name].to_numpy()
+            # first step : define np.ndarray to contains the arrays X,Y,Z
+            if arrays_pcl is None:
+                arrays_pcl = np.ndarray((3, array.reshape(-1).T.shape[0]))
+                # get only valid pixels
+            array = array.reshape(-1).T
+            # get layer into np.ndarray (laspy accept only XYZ in upper case)
+            arrays_pcl[coordinates.index(name.upper())] = array
+        elif name in input_color:
+            array = point_clouds[name].to_numpy()
+            if arrays_color is None:
+                arrays_color = np.ndarray((3, array.reshape(-1).T.shape[0]))
+            array = array.reshape(-1).T
+            maxi = 65535
+            if color_type:
+                if np.issubdtype(np.dtype(color_type), np.integer):
+                    maxi = np.min([maxi, np.iinfo(np.dtype(color_type)).max])
+            array[array >= maxi] = maxi
+            array[array <= 0] = 0
+
+            arrays_color[input_color.index(name)] = array
+            if nb_color == 1:
+                arrays_color[1] = array
+                arrays_color[2] = array
+    return arrays_pcl, arrays_color
+
+
+def generate_prj_file(output_filename, epsg):
+    """
+    Generate prj file associated to the laz file if projection is UTM or WGS84
+    :param output_filename: name of laz file
+    :param epsg: code of output epsg
+    """
+    with warnings.catch_warnings():
+        # Ignore some crs warning
+        warnings.filterwarnings(
+            "ignore",
+            category=UserWarning,
+            message=".*You will likely lose important projection"
+            " information when converting to a PROJ string from "
+            "another format.*",
+        )
+        crs = CRS.from_epsg(epsg)
+        proj = crs.to_proj4()
+    if crs.is_geographic:
+        logging.warning(
+            "Coordinate system of point cloud is geographic: "
+            "Display of LAZ file may not work"
+        )
+    with open(output_filename + ".prj", "w", encoding="utf8") as file_prj:
+        file_prj.write(proj)
+
+
+def generate_laz(
+    output_filename, coordinates, las_color, arrays_pcl, arrays_color
+):
+    """
+    Generate laz file from location and color arrays
+    """
+    # Create laz image
+    header = laspy.LasHeader(point_format=2)
+    scale_factor = 0.01
+    header.scales = [scale_factor, scale_factor, scale_factor]
+    laz = laspy.LasData(header)
+    # fill X,Y,Z into laspy structure, convert to cm
+    scale_multiplicator = 1 / scale_factor
+    for layer_index in range(arrays_pcl.shape[0]):
+        setattr(
+            laz,
+            [k for i, k in enumerate(coordinates) if i == layer_index][0],
+            scale_multiplicator * arrays_pcl[layer_index],
+        )
+    if arrays_color is not None:
+        for color_index in range(arrays_color.shape[0]):
+            setattr(
+                laz,
+                [k for i, k in enumerate(las_color) if i == color_index][0],
+                arrays_color[color_index],
+            )
+    laz.write(output_filename)