ign-borea 0.1.5__py3-none-any.whl

borea/process/p_format/p_read_opk.py

@@ -0,0 +1,78 @@
+"""
+Args of parser for reading opk file
+"""
+import argparse
+from borea.process.p_add_data.p_gen_param import args_general_param, process_args_gen_param
+from borea.process.p_add_data.p_unit_shot import args_input_shot
+from borea.worksite.worksite import Worksite
+from borea.reader.orientation.manage_reader import reader_orientation
+
+
+def args_reading_opk(parser: argparse) -> argparse:
+    """
+    Args for reading opk file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    # pylint: disable=duplicate-code
+    parser.add_argument('-r', '--filepath',
+                        type=str, help='File path of the workfile.')
+    parser.add_argument('-i', '--header',
+                        type=str, default="NXYZOPKC",
+                        help='Type of each column in the site file.'
+                        'e.g. NXYZOPKC'
+                        'S: to ignore the column'
+                        'N: name of shot'
+                        'X: coordinate x of the shot position'
+                        'Y: coordinate y of the shot position'
+                        'Z: coordinate z of the shot position in altitude'
+                        'H: coordinate z of the shot position in height'
+                        'O: omega rotation angle'
+                        'P: phi rotation angle'
+                        'K: kappa rotation angle'
+                        'C: name of the camera')
+    parser.add_argument('-f', '--first_line',
+                        type=int, default=1,
+                        help='Line number to start file playback. First line in the file is 1.'
+                             ' Does not take file header into account.')
+    parser.add_argument('-z', '--last_line',
+                        type=int, default=None,
+                        help='Line number to end file playback.'
+                             ' If not set, all lines below -f will be read.')
+    parser = args_input_shot(parser)
+    parser = args_general_param(parser)
+    return parser
+
+
+def process_args_read_opk(args: argparse) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data)
+
+    Returns:
+        Worksite: data
+    """
+    # Readind data
+    if args.filepath is not None:
+        if args.header is not None:
+            work = reader_orientation(args.filepath, {"order_axe": args.order_axe_input.lower(),
+                                                      "interval": [args.first_line, args.last_line],
+                                                      "header": list(args.header.upper()),
+                                                      "unit_angle": args.unit_angle,
+                                                      "linear_alteration": args.linear_alteration})
+            print("Orientation file reading done.")
+            print(f"Number of image: {len(work.shots)}")
+        else:
+            raise ValueError("The header file is missing -i.")
+    else:
+        raise ValueError("The access road to the photogrammetric site is missing -r.")
+
+    work = process_args_gen_param(args, work)
+
+    return work

borea/process/p_format/p_write_con.py

@@ -0,0 +1,36 @@
+"""
+Args of parser for writing conical file
+"""
+import argparse
+from borea.worksite.worksite import Worksite
+from borea.writer.manage_writer import manager_writer
+
+
+def args_write_con(parser: argparse) -> argparse:
+    """
+    Args for writing conical file of GEOVIEW IGN.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-w', '--pathreturn',
+                        type=str, default='./',
+                        help='Conversion path e.g. test/tmp/.')
+    return parser
+
+
+def process_args_write_con(args: argparse, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    # Writing data
+    print("Writing Conical file.")
+    manager_writer("con", None, args.pathreturn, None, work)
+    print(f"File written in folder {args.pathreturn} in .CON format.")

borea/process/p_format/p_write_opk.py

@@ -0,0 +1,64 @@
+"""
+Args of parser for writing opk file
+"""
+import argparse
+from borea.process.p_add_data.p_unit_shot import args_output_shot
+from borea.process.p_add_data.p_write import args_writer
+from borea.worksite.worksite import Worksite
+from borea.writer.manage_writer import manager_writer
+
+
+def args_writing_opk(parser: argparse) -> argparse:
+    """
+    Args for writing opk file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    # pylint: disable=duplicate-code
+    parser = args_writer(parser)
+    parser.add_argument('-o', '--output_header',
+                        type=str, default=None,
+                        help='Type of each column in the site file.'
+                        'e.g. NXYZOPKC'
+                        'N: name of shot'
+                        'X: coordinate x of the shot position'
+                        'Y: coordinate y of the shot position'
+                        'Z: coordinate z of the shot position in altitude'
+                        'H: coordinate z of the shot position in height'
+                        'O: omega rotation angle'
+                        'P: phi rotation angle'
+                        'K: kappa rotation angle'
+                        'C: name of the camera')
+    parser = args_output_shot(parser)
+    return parser
+
+
+def process_args_write_opk(args: argparse, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    if args.order_axe_output:
+        args.order_axe_output = args.order_axe_output.lower()
+
+    if args.output_header:
+        args.output_header = list(args.output_header.upper())
+
+    # Writing data
+    print("Writing OPK.")
+    if args.namereturn is not None:
+        args_writing = {"order_axe": args.order_axe_output,
+                        "header": args.output_header,
+                        "unit_angle": args.output_unit_angle,
+                        "linear_alteration": args.output_linear_alteration}
+        manager_writer("opk", args.namereturn, args.pathreturn, args_writing, work)
+        print(f"File written in {args.pathreturn + args.namereturn}.opk.")
+    else:
+        raise ValueError("The name of the saving file is missing -n.")

borea/process/p_format/p_write_rpc.py

@@ -0,0 +1,48 @@
+"""
+Args of parser for writing Rpc file
+"""
+import argparse
+from borea.worksite.worksite import Worksite
+from borea.writer.manage_writer import manager_writer
+
+
+def args_writing_rpc(parser: argparse) -> argparse:
+    """
+    Args for writing rpc file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser.add_argument('-w', '--pathreturn',
+                        type=str, default='./',
+                        help='Conversion path e.g. test/tmp/.')
+    parser.add_argument('-o', '--order',
+                        type=int, default=3, choices=[1, 2, 3],
+                        help="Degree of the polynomial of the rpc (1, 2, 3)")
+    parser.add_argument('-d', '--size_grid',
+                        type=int, default=100,
+                        help="Size of the grid to calculate Rpc.")
+    parser.add_argument('-l', '--fact_rpc',
+                        type=float, default=None,
+                        help="Factor Rpc for pyproj convertion.")
+    return parser
+
+
+def process_args_write_rpc(args: argparse, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    # Writing data
+    print("Writing Rpc.")
+    args_writing = {"order": args.order,
+                    "size_grid": args.size_grid,
+                    "fact_rpc": args.fact_rpc}
+    manager_writer("rpc", None, args.pathreturn, args_writing, work)
+    print(f"File written in folder {args.pathreturn} .txt.")

borea/process/p_func/p_control.py

@@ -0,0 +1,67 @@
+"""
+Args of parser to control file
+"""
+import argparse
+from borea.worksite.worksite import Worksite
+from borea.process.p_add_data.p_file_gcp2d import args_gcp2d, process_gcp2d
+from borea.process.p_add_data.p_file_gcp3d import args_gcp3d, process_gcp3d
+from borea.stat.statistics import Stat
+from borea.transform_world_image.transform_worksite.world_image_work import WorldImageWork
+from borea.transform_world_image.transform_worksite.image_world_work import ImageWorldWork
+
+
+def args_control(parser: argparse) -> argparse:
+    """
+    Args to control photogrametrique file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser = args_gcp2d(parser)
+    parser = args_gcp3d(parser)
+    parser.add_argument('-d', '--control_type',
+                        type=str, default=[], nargs='*',
+                        help='Type of gcp to control.')
+    parser.add_argument('-p', '--process',
+                        type=str, default="inter", choices=["inter", "square"],
+                        help="Type of process for the function image to world,"
+                             "intersection or least_square")
+    parser.add_argument('-w', '--pathreturn',
+                        type=str, default='./',
+                        help='Conversion path e.g. test/tmp/.')
+    return parser
+
+
+def process_args_control(args, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    # Read GCP 2D
+    work = process_gcp2d(args, work)
+
+    # Read GCP 3D
+    work = process_gcp3d(args, work)
+
+    # Calculate ground coordinate of conneting point by intersection
+    print("Calculation of data image to world.")
+    ImageWorldWork(work).manage_image_world(type_point="gcp2d",
+                                            type_process=args.process,
+                                            control_type=args.control_type)
+
+    # Calculate image coordinate of GCP if they exist
+    print("Calculation of data world to image.")
+    WorldImageWork(work).calculate_world_to_image(args.control_type)
+
+    # Statistics
+    print("Make statistics.")
+    stat = Stat(work, args.pathreturn, args.control_type)
+    stat.main_stat_and_save()
+    print("Statistics on control point, if there are,")
+    print(f" in {args.pathreturn}Stat_module_{work.name}.txt .")

borea/process/p_func/p_image_world.py

@@ -0,0 +1,48 @@
+"""
+Args of parser to calcule world coordinate.
+"""
+import argparse
+from borea.process.p_add_data.p_write import args_writer
+from borea.worksite.worksite import Worksite
+from borea.process.p_add_data.p_file_gcp2d import args_gcp2d, process_gcp2d
+from borea.transform_world_image.transform_worksite.image_world_work import ImageWorldWork
+from borea.writer.writer_df_to_txt import write_df_to_txt
+
+
+def args_image_world(parser: argparse) -> argparse:
+    """
+    Args to control photogrametrique file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser = args_gcp2d(parser)
+    parser.add_argument('-p', '--process',
+                        type=str, default="inter", choices=["inter", "square"],
+                        help="Type of process for the function image to world,"
+                             "intersection or least_square")
+    parser = args_writer(parser)
+    return parser
+
+
+def process_image_world(args, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    # Read GCP 2D
+    work = process_gcp2d(args, work)
+
+    # Calculate ground coordinate of conneting point by intersection
+    print("Calculation of data image to world.")
+    ImageWorldWork(work).manage_image_world(type_point="gcp2d",
+                                            type_process=args.process,
+                                            control_type=None)
+    df3d = work.get_point_world_dataframe("gcp2d", [])
+    write_df_to_txt(args.namereturn, args.pathreturn, df3d)

borea/process/p_func/p_spaceresection.py

@@ -0,0 +1,51 @@
+"""
+Args of parser to calcule 6 externals parameters of shots.
+"""
+import argparse
+
+import numpy as np
+from borea.process.p_add_data.p_file_gcp2d import args_gcp2d
+from borea.process.p_add_data.p_gen_param import args_general_param, process_args_gen_param
+from borea.process.p_add_data.p_pt3d import args_add_pt3d
+from borea.reader.reader_point import read_file_pt_dataframe
+from borea.transform_world_image.transform_worksite.space_resection import SpaceResection
+from borea.utils.check.check_args_opk import check_header_file
+from borea.worksite.worksite import Worksite
+from borea.process.p_add_data.p_file_gcp3d import args_gcp3d
+
+
+def args_space_resection(parser: argparse) -> argparse:
+    """
+    Args to calcule 6 externals parameters of shots.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser = args_add_pt3d(parser)
+    parser = args_general_param(parser)
+    parser = args_gcp2d(parser)
+    parser = args_gcp3d(parser)
+    return parser
+
+
+def process_space_resection(args: argparse) -> Worksite:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+
+    Returns:
+        Worksite: data
+    """
+    work = Worksite("Space_Resection")
+    work = process_args_gen_param(args, work)
+    work.set_type_z_shot(check_header_file(list(args.output_header.upper()))[1])
+    pt2d = read_file_pt_dataframe(args.gcp2d, list(args.head_gcp2d.upper()), "pt2d")
+    pt3d = read_file_pt_dataframe(args.gcp3d, list(args.head_gcp3d.upper()), "pt3d")
+    pinit = {"coor_init": np.array(args.point3d)}
+    SpaceResection(work).space_resection_to_worksite(pt2d, pt3d, pinit)
+    return work

borea/process/p_func/p_world_image.py

@@ -0,0 +1,49 @@
+"""
+Args of parser to calcule image coordinate.
+"""
+import argparse
+from borea.process.p_add_data.p_file_gcp2d import args_gcp2d, process_gcp2d
+from borea.process.p_add_data.p_write import args_writer
+from borea.worksite.worksite import Worksite
+from borea.process.p_add_data.p_file_gcp3d import args_gcp3d, process_gcp3d
+from borea.transform_world_image.transform_worksite.world_image_work import WorldImageWork
+from borea.writer.writer_df_to_txt import write_df_to_txt
+
+
+def args_world_image(parser: argparse) -> argparse:
+    """
+    Args to control photogrametrique file.
+
+    Args:
+        parser (argparse): Parser to add argument.
+
+    Returns:
+        argsparse: Parser with argument.
+    """
+    parser = args_gcp3d(parser)
+    parser = args_gcp2d(parser)
+    parser.add_argument('-d', '--control_type',
+                        type=str, default=[], nargs='*',
+                        help='Type of gcp to control.')
+    parser = args_writer(parser)
+    return parser
+
+
+def process_world_image(args, work: Worksite) -> None:
+    """
+    Processing args with data.
+
+    Args:
+        args (argparse): Arg to apply on worksite (data).
+        work (Worksite): Data.
+    """
+    # Read GCP 3D and 2D
+    work = process_gcp3d(args, work)
+    work = process_gcp2d(args, work)
+
+    # Calculate image coordinate of GCP if they exist
+    print("Calculation of data world to image.")
+    WorldImageWork(work).calculate_world_to_image(args.control_type)
+
+    df2d = work.get_point_image_dataframe("gcp3d", [])
+    write_df_to_txt(args.namereturn, args.pathreturn, df2d)

borea/reader/orientation/manage_reader.py

@@ -0,0 +1,33 @@
+"""
+Photogrammetry site file reader module.
+"""
+import importlib
+from pathlib import Path, PureWindowsPath
+from borea.worksite.worksite import Worksite
+
+
+def reader_orientation(file: str, args: dict) -> Worksite:
+    """
+    Photogrammetric site file reading function.
+
+    Args:
+        file (str): Path to the worksite.
+        args (dict): Other information for reading the file.
+
+    Returns:
+        Worksite: The worksite.
+    """
+    # Attention multiple file management orientation
+    # Attention management of files with the same extension but different formats
+    file = Path(PureWindowsPath(file))
+    name_work = file.stem
+    ext = file.suffix[1:]
+
+    work = Worksite(name_work)
+    try:
+        my_module = importlib.import_module("borea.reader.orientation.reader_" + ext.lower())
+        work = my_module.read(file, args, work)
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(f"{ext} file is not taken into account !!!") from e
+
+    return work

borea/reader/orientation/reader_opk.py

@@ -0,0 +1,58 @@
+"""
+A script to read opk file.
+"""
+import platform
+from pathlib import Path
+import numpy as np
+from borea.worksite.worksite import Worksite
+from borea.utils.check.check_args_opk import check_args_opk
+
+
+def read(file: Path, args: dict, work: Worksite) -> Worksite:
+    """
+    Reads an opk file to transform it into a Workside object.
+
+    Args:
+        file (Path): Path to the worksite.
+        args (dict): Information for reading an opk file.
+                     keys:
+                     "order_axe" (str): Order of rotation matrix axes,
+                     "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.
+        work (Worksite): Worksite to add shot.
+
+    Returns:
+        Worksite: The worksite.
+    """
+    args, header, type_z = check_args_opk(args)
+
+    try:
+        with open(file, 'r', encoding="utf-8") as file_opk:
+            for item_opk in file_opk.readlines()[args["interval"][0]:args["interval"][1]]:
+                if item_opk != '\n' and item_opk[0] != '#':
+                    item_shot = item_opk.split()
+                    if len(item_shot) != len(header):
+                        raise ValueError(f"The number of columns in your file {len(item_shot)}"
+                                         " is different from the number of columns in your input"
+                                         f" format {len(header)}.")
+                    work.add_shot(item_shot[header.index("N")],
+                                  np.array([float(item_shot[header.index("X")]),
+                                            float(item_shot[header.index("Y")]),
+                                            float(item_shot[header.index("Z")])], dtype=float),
+                                  np.array([float(item_shot[header.index("O")]),
+                                            float(item_shot[header.index("P")]),
+                                            float(item_shot[header.index("K")])], dtype=float),
+                                  item_shot[header.index("C")],
+                                  args["unit_angle"], args["linear_alteration"], args["order_axe"])
+            file_opk.close()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"The path {file} is incorrect !!! "
+                                f"or your os is {platform.system()}."
+                                "For Windows path is \\,"
+                                " for Linux and MacOS (Darwin) is / .") from e
+
+    work.type_z_shot = type_z
+    return work

borea/reader/reader_camera.py

@@ -0,0 +1,52 @@
+"""
+Script to read camera file txt or xml.
+"""
+from pathlib import Path, PureWindowsPath
+from borea.datastruct.camera import Camera
+from borea.worksite.worksite import Worksite
+
+
+def read_camera(files: list, work: Worksite) -> None:
+    """
+    Manage file in list files to read.
+
+    Args:
+        files (list): Path list of files cameras.
+        work (Worksite): Worksite which needs camera data.
+    """
+    for file in files:
+        camera_txt(Path(PureWindowsPath(file)), work)
+
+
+def camera_txt(file: Path, work: Worksite) -> None:
+    """
+    Read txt file camera.
+
+    Args:
+        files (Path): Path list of files cameras.
+        work (Worksite): Worksite which needs camera data.
+    """
+    dict_info = {}
+    try:
+        with open(file, 'r', encoding="utf-8") as file_cam:
+            for info_cam in file_cam.readlines():
+                if info_cam != '\n' and info_cam[0] != '#':
+                    # Camera info retrieval
+                    info_name, info_data = info_cam.split(" = ")
+                    dict_info[info_name.lower()] = info_data[:-1]
+
+            file_cam.close()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"The path {file} is incorrect !!!") from e
+
+    # Create Camera
+    cam = Camera(dict_info["name"])
+
+    for name_attr, item in dict_info.items():
+        if name_attr != "name":
+            type_item = int if name_attr in ["width", "height"] else float
+            try:
+                setattr(cam, name_attr.lower(), type_item(item))
+            except ValueError:
+                continue
+    work.cameras[dict_info["name"]] = cam