add python scripts

scripts/python/benchmark_eth3d.py

@@ -0,0 +1,183 @@
+import argparse
+import os
+import subprocess
+import sys
+import urllib.request
+
+
+def download_file(url, file_path, max_retries=3):
+    if os.path.exists(file_path):
+        return
+    print(f"Downloading {url} to {file_path}")
+    for retry in range(max_retries):
+        try:
+            urllib.request.urlretrieve(url, file_path)
+            return
+        except Exception as exc:
+            print(
+                f"Failed to download {url} (trial={retry + 1}) to {file_path} due to {exc}"
+            )
+
+
+def check_small_errors_or_exit(
+    dataset_name,
+    max_rotation_error,
+    max_proj_center_error,
+    expected_num_images,
+    errors_csv_path,
+):
+    print(f"Evaluating errors for {dataset_name}")
+
+    error = False
+    with open(errors_csv_path, "r") as fid:
+        num_images = 0
+        for line in fid:
+            line = line.strip()
+            if len(line) == 0 or line.startswith("#"):
+                continue
+            rotation_error, proj_center_error = map(float, line.split(","))
+            num_images += 1
+            if rotation_error > max_rotation_error:
+                print("Exceeded rotation error threshold:", rotation_error)
+                error = True
+            if proj_center_error > max_proj_center_error:
+                print(
+                    "Exceeded projection center error threshold:",
+                    proj_center_error,
+                )
+                error = True
+
+    if num_images != expected_num_images:
+        print("Unexpected number of images:", num_images)
+        error = True
+
+    if error:
+        sys.exit(1)
+
+
+def process_dataset(args, dataset_name):
+    print("Processing dataset:", dataset_name)
+
+    workspace_path = os.path.join(
+        os.path.realpath(args.workspace_path), dataset_name
+    )
+    os.makedirs(workspace_path, exist_ok=True)
+
+    dataset_archive_path = os.path.join(workspace_path, f"{dataset_name}.7z")
+    download_file(
+        f"https://www.eth3d.net/data/{dataset_name}_dslr_undistorted.7z",
+        dataset_archive_path,
+    )
+
+    subprocess.check_call(
+        ["7zz", "x", "-y", f"{dataset_name}.7z"], cwd=workspace_path
+    )
+
+    # Find undistorted parameters of first camera and initialize all images with it.
+    with open(
+        os.path.join(
+            workspace_path,
+            f"{dataset_name}/dslr_calibration_undistorted/cameras.txt",
+        ),
+        "r",
+    ) as fid:
+        for line in fid:
+            if not line.startswith("#"):
+                first_camera_data = line.split()
+                camera_model = first_camera_data[1]
+                assert camera_model == "PINHOLE"
+                camera_params = first_camera_data[4:]
+                assert len(camera_params) == 4
+                break
+
+    # Count the number of expected images in the GT.
+    expected_num_images = 0
+    with open(
+        os.path.join(
+            workspace_path,
+            f"{dataset_name}/dslr_calibration_undistorted/images.txt",
+        ),
+        "r",
+    ) as fid:
+        for line in fid:
+            if not line.startswith("#") and line.strip():
+                expected_num_images += 1
+    # Each image uses two consecutive lines.
+    assert expected_num_images % 2 == 0
+    expected_num_images /= 2
+
+    # Run automatic reconstruction pipeline.
+    subprocess.check_call(
+        [
+            os.path.realpath(args.colmap_path),
+            "automatic_reconstructor",
+            "--image_path",
+            f"{dataset_name}/images/",
+            "--workspace_path",
+            workspace_path,
+            "--use_gpu",
+            "1" if args.use_gpu else "0",
+            "--num_threads",
+            str(args.num_threads),
+            "--quality",
+            args.quality,
+            "--camera_model",
+            "PINHOLE",
+            "--camera_params",
+            ",".join(camera_params),
+        ],
+        cwd=workspace_path,
+    )
+
+    # Compare reconstructed model to GT model.
+    subprocess.check_call(
+        [
+            os.path.realpath(args.colmap_path),
+            "model_comparer",
+            "--input_path1",
+            "sparse/0",
+            "--input_path2",
+            f"{dataset_name}/dslr_calibration_undistorted/",
+            "--output_path",
+            ".",
+            "--alignment_error",
+            "proj_center",
+            "--max_proj_center_error",
+            str(args.max_proj_center_error),
+        ],
+        cwd=workspace_path,
+    )
+
+    # Ensure discrepancy between reconstructed model and GT is small.
+    check_small_errors_or_exit(
+        dataset_name,
+        args.max_rotation_error,
+        args.max_proj_center_error,
+        expected_num_images,
+        os.path.join(workspace_path, "errors.csv"),
+    )
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset_names", required=True)
+    parser.add_argument("--workspace_path", required=True)
+    parser.add_argument("--colmap_path", required=True)
+    parser.add_argument("--use_gpu", default=True, action="store_true")
+    parser.add_argument("--use_cpu", dest="use_gpu", action="store_false")
+    parser.add_argument("--num_threads", type=int, default=-1)
+    parser.add_argument("--quality", default="medium")
+    parser.add_argument("--max_rotation_error", type=float, default=1.0)
+    parser.add_argument("--max_proj_center_error", type=float, default=0.1)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    for dataset_name in args.dataset_names.split(","):
+        process_dataset(args, dataset_name.strip())
+
+
+if __name__ == "__main__":
+    main()

scripts/python/build_windows_app.py

@@ -0,0 +1,102 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import glob
+import os
+import shutil
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--install_path",
+        required=True,
+        help="The installation prefix, e.g., build/__install__",
+    )
+    parser.add_argument(
+        "--app_path",
+        required=True,
+        help="The application path, e.g., build/COLMAP-dev-windows",
+    )
+    args = parser.parse_args()
+    return args
+
+
+def mkdir_if_not_exists(path):
+    assert os.path.exists(os.path.dirname(os.path.abspath(path)))
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+
+def main():
+    args = parse_args()
+
+    mkdir_if_not_exists(args.app_path)
+    mkdir_if_not_exists(os.path.join(args.app_path, "bin"))
+    mkdir_if_not_exists(os.path.join(args.app_path, "lib"))
+    mkdir_if_not_exists(os.path.join(args.app_path, "lib/platforms"))
+
+    # Copy batch scripts to app directory.
+    shutil.copyfile(
+        os.path.join(args.install_path, "COLMAP.bat"),
+        os.path.join(args.app_path, "COLMAP.bat"),
+    )
+    shutil.copyfile(
+        os.path.join(args.install_path, "RUN_TESTS.bat"),
+        os.path.join(args.app_path, "RUN_TESTS.bat"),
+    )
+
+    # Copy executables to app directory.
+    exe_files = glob.glob(os.path.join(args.install_path, "bin/*.exe"))
+    for exe_file in exe_files:
+        shutil.copyfile(
+            exe_file,
+            os.path.join(args.app_path, "bin", os.path.basename(exe_file)),
+        )
+
+    # Copy shared libraries to app directory.
+    dll_files = glob.glob(os.path.join(args.install_path, "lib/*.dll"))
+    for dll_file in dll_files:
+        shutil.copyfile(
+            dll_file,
+            os.path.join(args.app_path, "lib", os.path.basename(dll_file)),
+        )
+    shutil.copyfile(
+        os.path.join(args.install_path, "lib/platforms/qwindows.dll"),
+        os.path.join(args.app_path, "lib/platforms/qwindows.dll"),
+    )
+
+    # Create zip archive for deployment.
+    shutil.make_archive(args.app_path, "zip", root_dir=args.app_path)
+
+
+if __name__ == "__main__":
+    main()

scripts/python/bundler_to_ply.py

@@ -0,0 +1,132 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script converts a Bundler reconstruction file to a PLY point cloud.
+
+import argparse
+
+import numpy as np
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--bundler_path", required=True)
+    parser.add_argument("--ply_path", required=True)
+    parser.add_argument("--normalize", type=bool, default=True)
+    parser.add_argument("--normalize_p0", type=float, default=0.2)
+    parser.add_argument("--normalize_p1", type=float, default=0.8)
+    parser.add_argument("--min_track_length", type=int, default=3)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    with open(args.bundler_path, "r") as fid:
+        line = fid.readline()
+        line = fid.readline()
+        num_images, num_points = map(int, line.split())
+
+        for i in range(5 * num_images):
+            fid.readline()
+
+        xyz = np.zeros((num_points, 3), dtype=np.float64)
+        rgb = np.zeros((num_points, 3), dtype=np.uint16)
+        track_lengths = np.zeros((num_points,), dtype=np.uint32)
+
+        for i in range(num_points):
+            if i % 1000 == 0:
+                print("Reading point", i, "/", num_points)
+            xyz[i] = map(float, fid.readline().split())
+            rgb[i] = map(int, fid.readline().split())
+            track_lengths[i] = int(fid.readline().split()[0])
+
+    mask = track_lengths >= args.min_track_length
+    xyz = xyz[mask]
+    rgb = rgb[mask]
+
+    if args.normalize:
+        sorted_x = np.sort(xyz[:, 0])
+        sorted_y = np.sort(xyz[:, 1])
+        sorted_z = np.sort(xyz[:, 2])
+
+        num_coords = sorted_x.size
+        min_coord = int(args.normalize_p0 * num_coords)
+        max_coord = int(args.normalize_p1 * num_coords)
+        mean_coords = xyz.mean(0)
+
+        bbox_min = np.array(
+            [sorted_x[min_coord], sorted_y[min_coord], sorted_z[min_coord]]
+        )
+        bbox_max = np.array(
+            [sorted_x[max_coord], sorted_y[max_coord], sorted_z[max_coord]]
+        )
+
+        extent = np.linalg.norm(bbox_max - bbox_min)
+        scale = 10.0 / extent
+
+        xyz -= mean_coords
+        xyz *= scale
+
+    xyz[:, 2] *= -1
+
+    with open(args.ply_path, "w") as fid:
+        fid.write("ply\n")
+        fid.write("format ascii 1.0\n")
+        fid.write("element vertex %d\n" % xyz.shape[0])
+        fid.write("property float x\n")
+        fid.write("property float y\n")
+        fid.write("property float z\n")
+        fid.write("property float nx\n")
+        fid.write("property float ny\n")
+        fid.write("property float nz\n")
+        fid.write("property uchar diffuse_red\n")
+        fid.write("property uchar diffuse_green\n")
+        fid.write("property uchar diffuse_blue\n")
+        fid.write("end_header\n")
+        for i in range(xyz.shape[0]):
+            if i % 1000 == 0:
+                print("Writing point", i, "/", xyz.shape[0])
+            fid.write(
+                "%f %f %f 0 0 0 %d %d %d\n"
+                % (
+                    xyz[i, 0],
+                    xyz[i, 1],
+                    xyz[i, 2],
+                    rgb[i, 0],
+                    rgb[i, 1],
+                    rgb[i, 2],
+                )
+            )
+
+
+if __name__ == "__main__":
+    main()

scripts/python/clang_format_code.py

@@ -0,0 +1,68 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import os
+import string
+import subprocess
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--path", required=True)
+    parser.add_argument("--exts", default=".h,.cc")
+    parser.add_argument("--style", default="File")
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    exts = map(string.lower, args.exts.split(","))
+
+    for root, subdirs, files in os.walk(args.path):
+        for f in files:
+            name, ext = os.path.splitext(f)
+            if ext.lower() in exts:
+                file_path = os.path.join(root, f)
+                proc = subprocess.Popen(
+                    ["clang-format", "--style", args.style, file_path],
+                    stdout=subprocess.PIPE,
+                )
+
+                text = "".join(proc.stdout)
+
+                with open(file_path, "w") as fd:
+                    fd.write(text)
+
+
+if __name__ == "__main__":
+    main()

scripts/python/crawl_camera_specs.py

@@ -0,0 +1,149 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import re
+
+import requests
+from lxml.html import soupparser
+
+MAX_REQUEST_TRIALS = 10
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--lib_path", required=True)
+    args = parser.parse_args()
+    return args
+
+
+def request_trial(func, *args, **kwargs):
+    for i in range(MAX_REQUEST_TRIALS):
+        try:
+            response = func(*args, **kwargs)
+        except:  # noqa E722
+            continue
+        else:
+            return response
+
+    raise SystemError
+
+
+def main():
+    args = parse_args()
+
+    ##########################################################################
+    # Header file
+    ##########################################################################
+
+    with open(args.lib_path + ".h", "w") as f:
+        f.write("#include <vector>\n")
+        f.write("#include <string>\n")
+        f.write("#include <unordered_map>\n\n")
+        f.write("// { make1 : ({ model1 : sensor-width in mm }, ...), ... }\n")
+        f.write(
+            "typedef std::vector<std::pair<std::string, float>> make_specs_t;\n"
+        )
+        f.write(
+            "typedef std::unordered_map<std::string, make_specs_t> camera_specs_t;;\n\n"
+        )
+        f.write("camera_specs_t InitializeCameraSpecs();\n\n")
+
+    ##########################################################################
+    # Source file
+    ##########################################################################
+
+    makes_response = requests.get("http://www.digicamdb.com")
+    makes_tree = soupparser.fromstring(makes_response.text)
+    makes_node = makes_tree.find('.//select[@id="select_brand"]')
+    makes = [b.attrib["value"] for b in makes_node.iter("option")]
+
+    with open(args.lib_path + ".cc", "w") as f:
+        f.write("camera_specs_t InitializeCameraSpecs() {\n")
+        f.write("  camera_specs_t specs;\n\n")
+        for make in makes:
+            f.write("  {\n")
+            f.write(
+                '    auto& make_specs = specs["%s"];\n'
+                % make.lower().replace(" ", "")
+            )
+
+            models_response = request_trial(
+                requests.post,
+                "http://www.digicamdb.com/inc/ajax.php",
+                data={"b": make, "role": "header_search"},
+            )
+
+            models_tree = soupparser.fromstring(models_response.text)
+            models_code = ""
+            num_models = 0
+            for model_node in models_tree.iter("option"):
+                model = model_node.attrib.get("value")
+                model_name = model_node.text
+                if model is None:
+                    continue
+
+                url = "http://www.digicamdb.com/specs/{0}_{1}".format(
+                    make, model
+                )
+                specs_response = request_trial(requests.get, url)
+
+                specs_tree = soupparser.fromstring(specs_response.text)
+                for spec in specs_tree.findall('.//td[@class="info_key"]'):
+                    if spec.text.strip() == "Sensor:":
+                        sensor_text = spec.find("..").find(
+                            './td[@class="bold"]'
+                        )
+                        sensor_text = sensor_text.text.strip()
+                        m = re.match(".*?([\d.]+) x ([\d.]+).*?", sensor_text)
+                        sensor_width = m.group(1)
+                        data = (
+                            model_name.lower().replace(" ", ""),
+                            float(sensor_width.replace(" ", "")),
+                        )
+                        models_code += (
+                            '    make_specs.emplace_back("%s", %.4ff);\n' % data
+                        )
+
+                        print(make, model_name)
+                        print("   ", sensor_text)
+
+                        num_models += 1
+
+            f.write("    make_specs.reserve(%d);\n" % num_models)
+            f.write(models_code)
+            f.write("  }\n\n")
+
+        f.write("  return specs;\n")
+        f.write("}\n")
+
+
+if __name__ == "__main__":
+    main()

scripts/python/database.py

@@ -0,0 +1,468 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script is based on an original implementation by True Price.
+
+import sqlite3
+import sys
+
+import numpy as np
+
+IS_PYTHON3 = sys.version_info[0] >= 3
+
+MAX_IMAGE_ID = 2**31 - 1
+
+CREATE_CAMERAS_TABLE = """CREATE TABLE IF NOT EXISTS cameras (
+    camera_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    model INTEGER NOT NULL,
+    width INTEGER NOT NULL,
+    height INTEGER NOT NULL,
+    params BLOB,
+    prior_focal_length INTEGER NOT NULL)"""
+
+CREATE_DESCRIPTORS_TABLE = """CREATE TABLE IF NOT EXISTS descriptors (
+    image_id INTEGER PRIMARY KEY NOT NULL,
+    rows INTEGER NOT NULL,
+    cols INTEGER NOT NULL,
+    data BLOB,
+    FOREIGN KEY(image_id) REFERENCES images(image_id) ON DELETE CASCADE)"""
+
+CREATE_IMAGES_TABLE = """CREATE TABLE IF NOT EXISTS images (
+    image_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    name TEXT NOT NULL UNIQUE,
+    camera_id INTEGER NOT NULL,
+    CONSTRAINT image_id_check CHECK(image_id >= 0 and image_id < {}),
+    FOREIGN KEY(camera_id) REFERENCES cameras(camera_id))
+""".format(MAX_IMAGE_ID)
+
+CREATE_POSE_PRIORS_TABLE = """CREATE TABLE IF NOT EXISTS pose_priors (
+    image_id INTEGER PRIMARY KEY NOT NULL,
+    position BLOB,
+    coordinate_system INTEGER NOT NULL,
+    position_covariance BLOB,
+    FOREIGN KEY(image_id) REFERENCES images(image_id) ON DELETE CASCADE)"""
+
+CREATE_TWO_VIEW_GEOMETRIES_TABLE = """
+CREATE TABLE IF NOT EXISTS two_view_geometries (
+    pair_id INTEGER PRIMARY KEY NOT NULL,
+    rows INTEGER NOT NULL,
+    cols INTEGER NOT NULL,
+    data BLOB,
+    config INTEGER NOT NULL,
+    F BLOB,
+    E BLOB,
+    H BLOB,
+    qvec BLOB,
+    tvec BLOB)
+"""
+
+CREATE_KEYPOINTS_TABLE = """CREATE TABLE IF NOT EXISTS keypoints (
+    image_id INTEGER PRIMARY KEY NOT NULL,
+    rows INTEGER NOT NULL,
+    cols INTEGER NOT NULL,
+    data BLOB,
+    FOREIGN KEY(image_id) REFERENCES images(image_id) ON DELETE CASCADE)
+"""
+
+CREATE_MATCHES_TABLE = """CREATE TABLE IF NOT EXISTS matches (
+    pair_id INTEGER PRIMARY KEY NOT NULL,
+    rows INTEGER NOT NULL,
+    cols INTEGER NOT NULL,
+    data BLOB)"""
+
+CREATE_NAME_INDEX = (
+    "CREATE UNIQUE INDEX IF NOT EXISTS index_name ON images(name)"
+)
+
+CREATE_ALL = "; ".join(
+    [
+        CREATE_CAMERAS_TABLE,
+        CREATE_IMAGES_TABLE,
+        CREATE_POSE_PRIORS_TABLE,
+        CREATE_KEYPOINTS_TABLE,
+        CREATE_DESCRIPTORS_TABLE,
+        CREATE_MATCHES_TABLE,
+        CREATE_TWO_VIEW_GEOMETRIES_TABLE,
+        CREATE_NAME_INDEX,
+    ]
+)
+
+
+def image_ids_to_pair_id(image_id1, image_id2):
+    if image_id1 > image_id2:
+        image_id1, image_id2 = image_id2, image_id1
+    return image_id1 * MAX_IMAGE_ID + image_id2
+
+
+def pair_id_to_image_ids(pair_id):
+    image_id2 = pair_id % MAX_IMAGE_ID
+    image_id1 = (pair_id - image_id2) / MAX_IMAGE_ID
+    return image_id1, image_id2
+
+
+def array_to_blob(array):
+    if IS_PYTHON3:
+        return array.tostring()
+    else:
+        return np.getbuffer(array)
+
+
+def blob_to_array(blob, dtype, shape=(-1,)):
+    if IS_PYTHON3:
+        return np.fromstring(blob, dtype=dtype).reshape(*shape)
+    else:
+        return np.frombuffer(blob, dtype=dtype).reshape(*shape)
+
+
+class COLMAPDatabase(sqlite3.Connection):
+    @staticmethod
+    def connect(database_path):
+        return sqlite3.connect(database_path, factory=COLMAPDatabase)
+
+    def __init__(self, *args, **kwargs):
+        super(COLMAPDatabase, self).__init__(*args, **kwargs)
+
+        self.create_tables = lambda: self.executescript(CREATE_ALL)
+        self.create_cameras_table = lambda: self.executescript(
+            CREATE_CAMERAS_TABLE
+        )
+        self.create_descriptors_table = lambda: self.executescript(
+            CREATE_DESCRIPTORS_TABLE
+        )
+        self.create_images_table = lambda: self.executescript(
+            CREATE_IMAGES_TABLE
+        )
+        self.create_pose_priors_table = lambda: self.executescript(
+            CREATE_POSE_PRIORS_TABLE
+        )
+        self.create_two_view_geometries_table = lambda: self.executescript(
+            CREATE_TWO_VIEW_GEOMETRIES_TABLE
+        )
+        self.create_keypoints_table = lambda: self.executescript(
+            CREATE_KEYPOINTS_TABLE
+        )
+        self.create_matches_table = lambda: self.executescript(
+            CREATE_MATCHES_TABLE
+        )
+        self.create_name_index = lambda: self.executescript(CREATE_NAME_INDEX)
+
+    def add_camera(
+        self,
+        model,
+        width,
+        height,
+        params,
+        prior_focal_length=False,
+        camera_id=None,
+    ):
+        params = np.asarray(params, np.float64)
+        cursor = self.execute(
+            "INSERT INTO cameras VALUES (?, ?, ?, ?, ?, ?)",
+            (
+                camera_id,
+                model,
+                width,
+                height,
+                array_to_blob(params),
+                prior_focal_length,
+            ),
+        )
+        return cursor.lastrowid
+
+    def add_image(
+        self,
+        name,
+        camera_id,
+        image_id=None,
+    ):
+        cursor = self.execute(
+            "INSERT INTO images VALUES (?, ?, ?)", (image_id, name, camera_id)
+        )
+        return cursor.lastrowid
+
+    def add_pose_prior(
+        self, image_id, position, coordinate_system=-1, position_covariance=None
+    ):
+        position = np.asarray(position, dtype=np.float64)
+        if position_covariance is None:
+            position_covariance = np.full((3, 3), np.nan, dtype=np.float64)
+        self.execute(
+            "INSERT INTO pose_priors VALUES (?, ?, ?, ?)",
+            (
+                image_id,
+                array_to_blob(position),
+                coordinate_system,
+                array_to_blob(position_covariance),
+            ),
+        )
+
+    def add_keypoints(self, image_id, keypoints):
+        assert len(keypoints.shape) == 2
+        assert keypoints.shape[1] in [2, 4, 6]
+
+        keypoints = np.asarray(keypoints, np.float32)
+        self.execute(
+            "INSERT INTO keypoints VALUES (?, ?, ?, ?)",
+            (image_id,) + keypoints.shape + (array_to_blob(keypoints),),
+        )
+
+    def add_descriptors(self, image_id, descriptors):
+        descriptors = np.ascontiguousarray(descriptors, np.uint8)
+        self.execute(
+            "INSERT INTO descriptors VALUES (?, ?, ?, ?)",
+            (image_id,) + descriptors.shape + (array_to_blob(descriptors),),
+        )
+
+    def add_matches(self, image_id1, image_id2, matches):
+        assert len(matches.shape) == 2
+        assert matches.shape[1] == 2
+
+        if image_id1 > image_id2:
+            matches = matches[:, ::-1]
+
+        pair_id = image_ids_to_pair_id(image_id1, image_id2)
+        matches = np.asarray(matches, np.uint32)
+        self.execute(
+            "INSERT INTO matches VALUES (?, ?, ?, ?)",
+            (pair_id,) + matches.shape + (array_to_blob(matches),),
+        )
+
+    def add_two_view_geometry(
+        self,
+        image_id1,
+        image_id2,
+        matches,
+        F=np.eye(3),
+        E=np.eye(3),
+        H=np.eye(3),
+        qvec=np.array([1.0, 0.0, 0.0, 0.0]),
+        tvec=np.zeros(3),
+        config=2,
+    ):
+        assert len(matches.shape) == 2
+        assert matches.shape[1] == 2
+
+        if image_id1 > image_id2:
+            matches = matches[:, ::-1]
+
+        pair_id = image_ids_to_pair_id(image_id1, image_id2)
+        matches = np.asarray(matches, np.uint32)
+        F = np.asarray(F, dtype=np.float64)
+        E = np.asarray(E, dtype=np.float64)
+        H = np.asarray(H, dtype=np.float64)
+        qvec = np.asarray(qvec, dtype=np.float64)
+        tvec = np.asarray(tvec, dtype=np.float64)
+        self.execute(
+            "INSERT INTO two_view_geometries VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (pair_id,)
+            + matches.shape
+            + (
+                array_to_blob(matches),
+                config,
+                array_to_blob(F),
+                array_to_blob(E),
+                array_to_blob(H),
+                array_to_blob(qvec),
+                array_to_blob(tvec),
+            ),
+        )
+
+
+def example_usage():
+    import argparse
+    import os
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", default="database.db")
+    args = parser.parse_args()
+
+    if os.path.exists(args.database_path):
+        print("ERROR: database path already exists -- will not modify it.")
+        return
+
+    # Open the database.
+
+    db = COLMAPDatabase.connect(args.database_path)
+
+    # For convenience, try creating all the tables upfront.
+
+    db.create_tables()
+
+    # Create dummy cameras.
+
+    model1, width1, height1, params1 = (
+        0,
+        1024,
+        768,
+        np.array((1024.0, 512.0, 384.0)),
+    )
+    model2, width2, height2, params2 = (
+        2,
+        1024,
+        768,
+        np.array((1024.0, 512.0, 384.0, 0.1)),
+    )
+
+    camera_id1 = db.add_camera(model1, width1, height1, params1)
+    camera_id2 = db.add_camera(model2, width2, height2, params2)
+
+    # Create dummy images.
+
+    image_id1 = db.add_image("image1.png", camera_id1)
+    image_id2 = db.add_image("image2.png", camera_id1)
+    image_id3 = db.add_image("image3.png", camera_id2)
+    image_id4 = db.add_image("image4.png", camera_id2)
+
+    # Create dummy keypoints.
+    #
+    # Note that COLMAP supports:
+    #      - 2D keypoints: (x, y)
+    #      - 4D keypoints: (x, y, theta, scale)
+    #      - 6D affine keypoints: (x, y, a_11, a_12, a_21, a_22)
+
+    num_keypoints = 1000
+    keypoints1 = np.random.rand(num_keypoints, 2) * (width1, height1)
+    keypoints2 = np.random.rand(num_keypoints, 2) * (width1, height1)
+    keypoints3 = np.random.rand(num_keypoints, 2) * (width2, height2)
+    keypoints4 = np.random.rand(num_keypoints, 2) * (width2, height2)
+
+    db.add_keypoints(image_id1, keypoints1)
+    db.add_keypoints(image_id2, keypoints2)
+    db.add_keypoints(image_id3, keypoints3)
+    db.add_keypoints(image_id4, keypoints4)
+
+    # Create dummy matches.
+
+    M = 50
+    matches12 = np.random.randint(num_keypoints, size=(M, 2))
+    matches23 = np.random.randint(num_keypoints, size=(M, 2))
+    matches34 = np.random.randint(num_keypoints, size=(M, 2))
+
+    db.add_matches(image_id1, image_id2, matches12)
+    db.add_matches(image_id2, image_id3, matches23)
+    db.add_matches(image_id3, image_id4, matches34)
+
+    # Create dummy pose_priors.
+
+    pos1 = np.random.rand(3, 1) * np.random.randint(10)
+    pos2 = np.random.rand(3, 1) * np.random.randint(10)
+    pos3 = np.random.rand(3, 1) * np.random.randint(10)
+
+    cov3 = np.random.rand(3, 3) * np.random.randint(10)
+
+    pose_prior1 = [image_id1, pos1, 1, None]
+    pose_prior2 = [image_id2, pos2, -1, None]
+    pose_prior3 = [image_id3, pos3, 0, cov3]
+
+    db.add_pose_prior(*pose_prior1)
+    db.add_pose_prior(*pose_prior2)
+    db.add_pose_prior(*pose_prior3)
+
+    # Convert unset covariance to nan matrix for later check
+    pose_prior1[3] = np.full((3, 3), np.nan, dtype=np.float64)
+    pose_prior2[3] = np.full((3, 3), np.nan, dtype=np.float64)
+
+    # Commit the data to the file.
+
+    db.commit()
+
+    # Read and check cameras.
+
+    rows = db.execute("SELECT * FROM cameras")
+
+    camera_id, model, width, height, params, prior = next(rows)
+    params = blob_to_array(params, np.float64)
+    assert camera_id == camera_id1
+    assert model == model1 and width == width1 and height == height1
+    assert np.allclose(params, params1)
+
+    camera_id, model, width, height, params, prior = next(rows)
+    params = blob_to_array(params, np.float64)
+    assert camera_id == camera_id2
+    assert model == model2 and width == width2 and height == height2
+    assert np.allclose(params, params2)
+
+    # Read and check keypoints.
+
+    keypoints = dict(
+        (image_id, blob_to_array(data, np.float32, (-1, 2)))
+        for image_id, data in db.execute("SELECT image_id, data FROM keypoints")
+    )
+
+    assert np.allclose(keypoints[image_id1], keypoints1)
+    assert np.allclose(keypoints[image_id2], keypoints2)
+    assert np.allclose(keypoints[image_id3], keypoints3)
+    assert np.allclose(keypoints[image_id4], keypoints4)
+
+    # Read and check matches.
+
+    matches = dict(
+        (pair_id_to_image_ids(pair_id), blob_to_array(data, np.uint32, (-1, 2)))
+        for pair_id, data in db.execute("SELECT pair_id, data FROM matches")
+    )
+
+    assert np.all(matches[(image_id1, image_id2)] == matches12)
+    assert np.all(matches[(image_id2, image_id3)] == matches23)
+    assert np.all(matches[(image_id3, image_id4)] == matches34)
+
+    # Read and check pose_priors
+
+    rows = db.execute("SELECT * FROM pose_priors")
+
+    img_id1, pos1, coord_sys1, cov1 = next(rows)
+    img_id2, pos2, coord_sys2, cov2 = next(rows)
+    img_id3, pos3, coord_sys3, cov3 = next(rows)
+
+    assert pose_prior1[0] == img_id1
+    assert pose_prior2[0] == img_id2
+    assert pose_prior3[0] == img_id3
+
+    assert pose_prior1[1].all() == blob_to_array(pos1, np.float64, (3, 1)).all()
+    assert pose_prior2[1].all() == blob_to_array(pos2, np.float64, (3, 1)).all()
+    assert pose_prior3[1].all() == blob_to_array(pos3, np.float64, (3, 1)).all()
+
+    assert pose_prior1[2] == coord_sys1
+    assert pose_prior2[2] == coord_sys2
+    assert pose_prior3[2] == coord_sys3
+
+    assert pose_prior1[3].all() == blob_to_array(cov1, np.float64, (3, 3)).all()
+    assert pose_prior2[3].all() == blob_to_array(cov2, np.float64, (3, 3)).all()
+    assert pose_prior3[3].all() == blob_to_array(cov3, np.float64, (3, 3)).all()
+
+    # Clean up.
+
+    db.close()
+
+    if os.path.exists(args.database_path):
+        os.remove(args.database_path)
+
+
+if __name__ == "__main__":
+    example_usage()

scripts/python/export_inlier_matches.py

@@ -0,0 +1,93 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script exports inlier matches from a COLMAP database to a text file.
+
+import argparse
+import os
+import sqlite3
+
+import numpy as np
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", required=True)
+    parser.add_argument("--output_path", required=True)
+    parser.add_argument("--min_num_matches", type=int, default=15)
+    args = parser.parse_args()
+    return args
+
+
+def pair_id_to_image_ids(pair_id):
+    image_id2 = pair_id % 2147483647
+    image_id1 = (pair_id - image_id2) / 2147483647
+    return image_id1, image_id2
+
+
+def main():
+    args = parse_args()
+
+    connection = sqlite3.connect(args.database_path)
+    cursor = connection.cursor()
+
+    images = {}
+    cursor.execute("SELECT image_id, camera_id, name FROM images;")
+    for row in cursor:
+        image_id = row[0]
+        image_name = row[2]
+        images[image_id] = image_name
+
+    with open(os.path.join(args.output_path), "w") as fid:
+        cursor.execute(
+            "SELECT pair_id, data FROM two_view_geometries WHERE rows>=?;",
+            (args.min_num_matches,),
+        )
+        for row in cursor:
+            pair_id = row[0]
+            inlier_matches = np.fromstring(row[1], dtype=np.uint32).reshape(
+                -1, 2
+            )
+            image_id1, image_id2 = pair_id_to_image_ids(pair_id)
+            image_name1 = images[image_id1]
+            image_name2 = images[image_id2]
+            fid.write(
+                "%s %s %d\n"
+                % (image_name1, image_name2, inlier_matches.shape[0])
+            )
+            for i in range(inlier_matches.shape[0]):
+                fid.write("%d %d\n" % tuple(inlier_matches[i]))
+
+    cursor.close()
+    connection.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/python/export_inlier_pairs.py

@@ -0,0 +1,88 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script exports inlier image pairs from a COLMAP database to a text file.
+
+import argparse
+import sqlite3
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", required=True)
+    parser.add_argument("--match_list_path", required=True)
+    parser.add_argument("--min_num_matches", type=int, default=15)
+    args = parser.parse_args()
+    return args
+
+
+def pair_id_to_image_ids(pair_id):
+    image_id2 = pair_id % 2147483647
+    image_id1 = (pair_id - image_id2) / 2147483647
+    return image_id1, image_id2
+
+
+def main():
+    args = parse_args()
+
+    connection = sqlite3.connect(args.database_path)
+    cursor = connection.cursor()
+
+    # Get a mapping between image ids and image names
+    image_id_to_name = dict()
+    cursor.execute("SELECT image_id, name FROM images;")
+    for row in cursor:
+        image_id = row[0]
+        name = row[1]
+        image_id_to_name[image_id] = name
+
+    # Iterate over entries in the two_view_geometries table
+    output = open(args.match_list_path, "w")
+    cursor.execute("SELECT pair_id, rows FROM two_view_geometries;")
+    for row in cursor:
+        pair_id = row[0]
+        rows = row[1]
+
+        if rows < args.min_num_matches:
+            continue
+
+        image_id1, image_id2 = pair_id_to_image_ids(pair_id)
+        image_name1 = image_id_to_name[image_id1]
+        image_name2 = image_id_to_name[image_id2]
+
+        output.write("%s %s\n" % (image_name1, image_name2))
+
+    output.close()
+    cursor.close()
+    connection.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/python/export_to_bundler.py

@@ -0,0 +1,178 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script exports a COLMAP database to the file structure to run Bundler.
+
+import argparse
+import gzip
+import os
+import shutil
+import sqlite3
+
+import numpy as np
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", required=True)
+    parser.add_argument("--image_path", required=True)
+    parser.add_argument("--output_path", required=True)
+    parser.add_argument("--min_num_matches", type=int, default=15)
+    args = parser.parse_args()
+    return args
+
+
+def pair_id_to_image_ids(pair_id):
+    image_id2 = pair_id % 2147483647
+    image_id1 = (pair_id - image_id2) / 2147483647
+    return image_id1, image_id2
+
+
+def main():
+    args = parse_args()
+
+    connection = sqlite3.connect(args.database_path)
+    cursor = connection.cursor()
+
+    try:
+        os.makedirs(args.output_path)
+    except:  # noqa E722
+        pass
+
+    cameras = {}
+    cursor.execute("SELECT camera_id, params FROM cameras;")
+    for row in cursor:
+        camera_id = row[0]
+        params = np.fromstring(row[1], dtype=np.double)
+        cameras[camera_id] = params
+
+    images = {}
+    with open(os.path.join(args.output_path, "list.txt"), "w") as fid:
+        cursor.execute("SELECT image_id, camera_id, name FROM images;")
+        for row in cursor:
+            image_id = row[0]
+            camera_id = row[1]
+            image_name = row[2]
+            print("Copying image", image_name)
+            images[image_id] = (len(images), image_name)
+            fid.write("./%s 0 %f\n" % (image_name, cameras[camera_id][0]))
+            if not os.path.exists(os.path.join(args.output_path, image_name)):
+                shutil.copyfile(
+                    os.path.join(args.image_path, image_name),
+                    os.path.join(args.output_path, image_name),
+                )
+
+    for image_id, (image_idx, image_name) in images.iteritems():
+        print("Exporting key file for", image_name)
+        base_name, ext = os.path.splitext(image_name)
+        key_file_name = os.path.join(args.output_path, base_name + ".key")
+        key_file_name_gz = key_file_name + ".gz"
+        if os.path.exists(key_file_name_gz):
+            continue
+
+        cursor.execute(
+            "SELECT data FROM keypoints WHERE image_id=?;", (image_id,)
+        )
+        row = next(cursor)
+        if row[0] is None:
+            keypoints = np.zeros((0, 6), dtype=np.float32)
+            descriptors = np.zeros((0, 128), dtype=np.uint8)
+        else:
+            keypoints = np.fromstring(row[0], dtype=np.float32).reshape(-1, 6)
+            cursor.execute(
+                "SELECT data FROM descriptors WHERE image_id=?;", (image_id,)
+            )
+            row = next(cursor)
+            descriptors = np.fromstring(row[0], dtype=np.uint8).reshape(-1, 128)
+
+        with open(key_file_name, "w") as fid:
+            fid.write("%d %d\n" % (keypoints.shape[0], descriptors.shape[1]))
+            for r in range(keypoints.shape[0]):
+                fid.write(
+                    "%f %f %f %f\n"
+                    % (
+                        keypoints[r, 1],
+                        keypoints[r, 0],
+                        keypoints[r, 2],
+                        keypoints[r, 3],
+                    )
+                )
+                for i in range(0, 128, 20):
+                    desc_block = descriptors[r, i : i + 20]
+                    fid.write(" ".join(map(str, desc_block.ravel().tolist())))
+                    fid.write("\n")
+
+        with open(key_file_name, "rb") as fid_in:
+            with gzip.open(key_file_name + ".gz", "wb") as fid_out:
+                fid_out.writelines(fid_in)
+
+        os.remove(key_file_name)
+
+    with open(os.path.join(args.output_path, "matches.init.txt"), "w") as fid:
+        cursor.execute(
+            "SELECT pair_id, data FROM two_view_geometries WHERE rows>=?;",
+            (args.min_num_matches,),
+        )
+        for row in cursor:
+            pair_id = row[0]
+            inlier_matches = np.fromstring(row[1], dtype=np.uint32).reshape(
+                -1, 2
+            )
+            image_id1, image_id2 = pair_id_to_image_ids(pair_id)
+            image_idx1 = images[image_id1][0]
+            image_idx2 = images[image_id2][0]
+            fid.write(
+                "%d %d\n%d\n"
+                % (image_idx1, image_idx2, inlier_matches.shape[0])
+            )
+            for i in range(inlier_matches.shape[0]):
+                fid.write(
+                    "%d %d\n" % (inlier_matches[i, 0], inlier_matches[i, 1])
+                )
+
+    with open(os.path.join(args.output_path, "run_bundler.sh"), "w") as fid:
+        fid.write("bin/Bundler list.txt \\\n")
+        fid.write("--run_bundle \\\n")
+        fid.write("--use_focal_estimate \\\n")
+        fid.write("--output_all bundle_ \\\n")
+        fid.write("--constrain_focal \\\n")
+        fid.write("--estimate_distortion \\\n")
+        fid.write("--match_table matches.init.txt \\\n")
+        fid.write("--variable_focal_length \\\n")
+        fid.write("--output_dir bundle \\\n")
+        fid.write("--output bundle.out \\\n")
+        fid.write("--constrain_focal_weight 0.0001 \\\n")
+
+    cursor.close()
+    connection.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/python/export_to_visualsfm.py

@@ -0,0 +1,171 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script exports a COLMAP database to the file structure to run VisualSfM.
+
+import argparse
+import os
+import shutil
+import sqlite3
+import struct
+
+import numpy as np
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", required=True)
+    parser.add_argument("--image_path", required=True)
+    parser.add_argument("--output_path", required=True)
+    parser.add_argument("--min_num_matches", type=int, default=15)
+    parser.add_argument("--binary_feature_files", type=bool, default=True)
+    args = parser.parse_args()
+    return args
+
+
+def pair_id_to_image_ids(pair_id):
+    image_id2 = pair_id % 2147483647
+    image_id1 = (pair_id - image_id2) / 2147483647
+    return image_id1, image_id2
+
+
+def main():
+    args = parse_args()
+
+    connection = sqlite3.connect(args.database_path)
+    cursor = connection.cursor()
+
+    try:
+        os.makedirs(args.output_path)
+    except:  # noqa E722
+        pass
+
+    cameras = {}
+    cursor.execute("SELECT camera_id, params FROM cameras;")
+    for row in cursor:
+        camera_id = row[0]
+        params = np.fromstring(row[1], dtype=np.double)
+        cameras[camera_id] = params
+
+    images = {}
+    cursor.execute("SELECT image_id, camera_id, name FROM images;")
+    for row in cursor:
+        image_id = row[0]
+        camera_id = row[1]
+        image_name = row[2]
+        print("Copying image", image_name)
+        images[image_id] = (len(images), image_name)
+        if not os.path.exists(os.path.join(args.output_path, image_name)):
+            shutil.copyfile(
+                os.path.join(args.image_path, image_name),
+                os.path.join(args.output_path, image_name),
+            )
+
+    # The magic numbers used in VisualSfM's binary file format for storing the
+    # feature descriptors.
+    sift_name = 1413892435
+    sift_version_v4 = 808334422
+    sift_eof_marker = 1179600383
+
+    for image_id, (image_idx, image_name) in images.iteritems():
+        print("Exporting key file for", image_name)
+        base_name, ext = os.path.splitext(image_name)
+        key_file_name = os.path.join(args.output_path, base_name + ".sift")
+        if os.path.exists(key_file_name):
+            continue
+
+        cursor.execute(
+            "SELECT data FROM keypoints WHERE image_id=?;", (image_id,)
+        )
+        row = next(cursor)
+        if row[0] is None:
+            keypoints = np.zeros((0, 6), dtype=np.float32)
+            descriptors = np.zeros((0, 128), dtype=np.uint8)
+        else:
+            keypoints = np.fromstring(row[0], dtype=np.float32).reshape(-1, 6)
+            cursor.execute(
+                "SELECT data FROM descriptors WHERE image_id=?;", (image_id,)
+            )
+            row = next(cursor)
+            descriptors = np.fromstring(row[0], dtype=np.uint8).reshape(-1, 128)
+
+        if args.binary_feature_files:
+            with open(key_file_name, "wb") as fid:
+                fid.write(struct.pack("i", sift_name))
+                fid.write(struct.pack("i", sift_version_v4))
+                fid.write(struct.pack("i", keypoints.shape[0]))
+                fid.write(struct.pack("i", 4))
+                fid.write(struct.pack("i", 128))
+                keypoints[:, :4].astype(np.float32).tofile(fid)
+                descriptors.astype(np.uint8).tofile(fid)
+                fid.write(struct.pack("i", sift_eof_marker))
+        else:
+            with open(key_file_name, "w") as fid:
+                fid.write(
+                    "%d %d\n" % (keypoints.shape[0], descriptors.shape[1])
+                )
+                for r in range(keypoints.shape[0]):
+                    fid.write("%f %f 0 0 " % (keypoints[r, 0], keypoints[r, 1]))
+                    fid.write(
+                        " ".join(map(str, descriptors[r].ravel().tolist()))
+                    )
+                    fid.write("\n")
+
+    with open(os.path.join(args.output_path, "matches.txt"), "w") as fid:
+        cursor.execute(
+            "SELECT pair_id, data FROM two_view_geometries WHERE rows>=?;",
+            (args.min_num_matches,),
+        )
+        for row in cursor:
+            pair_id = row[0]
+            inlier_matches = np.fromstring(row[1], dtype=np.uint32).reshape(
+                -1, 2
+            )
+            image_id1, image_id2 = pair_id_to_image_ids(pair_id)
+            image_name1 = images[image_id1][1]
+            image_name2 = images[image_id2][1]
+            fid.write(
+                "%s %s %d\n"
+                % (image_name1, image_name2, inlier_matches.shape[0])
+            )
+            line1 = ""
+            line2 = ""
+            for i in range(inlier_matches.shape[0]):
+                line1 += "%d " % inlier_matches[i, 0]
+                line2 += "%d " % inlier_matches[i, 1]
+            fid.write(line1 + "\n")
+            fid.write(line2 + "\n")
+
+    cursor.close()
+    connection.close()
+
+
+if __name__ == "__main__":
+    main()

scripts/python/flickr_downloader.py

@@ -0,0 +1,205 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import datetime
+import multiprocessing
+import os
+import socket
+import time
+import urllib
+import xml.etree.ElementTree as ElementTree
+
+import urllib2
+import urlparse
+
+PER_PAGE = 500
+SORT = "date-posted-desc"
+URL = (
+    "https://api.flickr.com/services/rest/?method=flickr.photos.search&"
+    "api_key=%s&text=%s&sort=%s&per_page=%d&page=%d&min_upload_date=%s&"
+    "max_upload_date=%s&format=rest&extras=url_o,url_l,url_c,url_z,url_n"
+)
+MAX_PAGE_REQUESTS = 5
+MAX_PAGE_TIMEOUT = 20
+MAX_IMAGE_REQUESTS = 3
+TIME_SKIP = 24 * 60 * 60
+MAX_DATE = time.time()
+MIN_DATE = MAX_DATE - TIME_SKIP
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--search_text", required=True)
+    parser.add_argument("--api_key", required=True)
+    parser.add_argument("--image_path", required=True)
+    parser.add_argument("--num_procs", type=int, default=10)
+    parser.add_argument("--max_days_without_image", type=int, default=365)
+    args = parser.parse_args()
+    return args
+
+
+def compose_url(page, api_key, text, min_date, max_date):
+    return URL % (
+        api_key,
+        text,
+        SORT,
+        PER_PAGE,
+        page,
+        str(min_date),
+        str(max_date),
+    )
+
+
+def parse_page(page, api_key, text, min_date, max_date):
+    f = None
+    for _ in range(MAX_PAGE_REQUESTS):
+        try:
+            f = urllib2.urlopen(
+                compose_url(page, api_key, text, min_date, max_date),
+                timeout=MAX_PAGE_TIMEOUT,
+            )
+        except socket.timeout:
+            continue
+        else:
+            break
+
+    if f is None:
+        return {
+            "pages": "0",
+            "total": "0",
+            "page": "0",
+            "perpage": "0",
+        }, tuple()
+
+    response = f.read()
+    root = ElementTree.fromstring(response)
+
+    if root.attrib["stat"] != "ok":
+        raise IOError
+
+    photos = []
+    for photo in root.iter("photo"):
+        photos.append(photo.attrib)
+
+    return root.find("photos").attrib, photos
+
+
+class PhotoDownloader(object):
+    def __init__(self, image_path):
+        self.image_path = image_path
+
+    def __call__(self, photo):
+        # Find the URL corresponding to the highest image resolution. We will
+        # need this URL here to determine the image extension (typically .jpg,
+        # but could be .png, .gif, etc).
+        url = None
+        for url_suffix in ("o", "l", "k", "h", "b", "c", "z"):
+            url_attr = "url_%s" % url_suffix
+            if photo.get(url_attr) is not None:
+                url = photo.get(url_attr)
+                break
+
+        if url is not None:
+            # Note that the following statement may fail in Python 3. urlparse
+            # may need to be replaced with urllib.parse.
+            url_filename = urlparse.urlparse(url).path
+            image_ext = os.path.splitext(url_filename)[1]
+
+            image_name = "%s_%s%s" % (photo["id"], photo["secret"], image_ext)
+            path = os.path.join(self.image_path, image_name)
+            if not os.path.exists(path):
+                print(url)
+                for _ in range(MAX_IMAGE_REQUESTS):
+                    try:
+                        urllib.urlretrieve(url, path)
+                    except urllib.ContentTooShortError:
+                        continue
+                    else:
+                        break
+
+
+def main():
+    args = parse_args()
+
+    downloader = PhotoDownloader(args.image_path)
+    pool = multiprocessing.Pool(processes=args.num_procs)
+
+    num_pages = float("inf")
+    page = 0
+
+    min_date = MIN_DATE
+    max_date = MAX_DATE
+
+    days_in_row = 0
+
+    search_text = args.search_text.replace(" ", "-")
+
+    while num_pages > page:
+        page += 1
+
+        metadata, photos = parse_page(
+            page, args.api_key, search_text, min_date, max_date
+        )
+
+        num_pages = int(metadata["pages"])
+
+        print(78 * "=")
+        print("Page:\t\t", page, "of", num_pages)
+        print("Min-Date:\t", datetime.datetime.fromtimestamp(min_date))
+        print("Max-Date:\t", datetime.datetime.fromtimestamp(max_date))
+        print("Num-Photos:\t", len(photos))
+        print(78 * "=")
+
+        try:
+            pool.map_async(downloader, photos).get(1e10)
+        except KeyboardInterrupt:
+            pool.wait()
+            break
+
+        if page >= num_pages:
+            max_date -= TIME_SKIP
+            min_date -= TIME_SKIP
+            page = 0
+
+        if num_pages == 0:
+            days_in_row = days_in_row + 1
+            num_pages = float("inf")
+
+            print("    No images in", days_in_row, "days in a row")
+
+            if days_in_row == args.max_days_without_image:
+                break
+        else:
+            days_in_row = 0
+
+
+if __name__ == "__main__":
+    main()

scripts/python/merge_ply_files.py

@@ -0,0 +1,70 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script merges multiple homogeneous PLY files into a single PLY file.
+
+import argparse
+import os
+
+import numpy as np
+import plyfile
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--folder_path", required=True)
+    parser.add_argument("--merged_path", required=True)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    files = []
+    for file_name in os.listdir(args.folder_path):
+        if len(file_name) < 4 or file_name[-4:].lower() != ".ply":
+            continue
+
+        print("Reading file", file_name)
+        file = plyfile.PlyData.read(os.path.join(args.folder_path, file_name))
+        for element in file.elements:
+            files.append(element.data)
+
+    print("Merging files")
+    merged_file = np.concatenate(files, -1)
+    merged_el = plyfile.PlyElement.describe(merged_file, "vertex")
+
+    print("Writing merged file")
+    plyfile.PlyData([merged_el]).write(args.merged_path)
+
+
+if __name__ == "__main__":
+    main()

scripts/python/migrate_database_pose_prior.py

@@ -0,0 +1,80 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+
+import numpy as np
+from database import COLMAPDatabase
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--database_path", type=str, required=True)
+    parser.add_argument("--is_cartesian", action="store_true")
+    parser.add_argument("--cleanup", action="store_true")
+    args = parser.parse_args()
+
+    db = COLMAPDatabase.connect(args.database_path)
+
+    pose_priors = {}
+    rows = db.execute("SELECT * FROM images")
+    for image_id, _, _, *cam_from_world_prior in rows:
+        if not cam_from_world_prior:  # newer format database
+            continue
+        qvec = np.array(cam_from_world_prior[:4], dtype=float)
+        tvec = np.array(cam_from_world_prior[4:], dtype=float)
+        if np.isfinite(qvec).any():
+            print(
+                f"Warning: rotation prior for image {image_id} "
+                "will be lost during migration."
+            )
+        if np.isfinite(tvec).any():
+            pose_priors[image_id] = tvec
+    print(f"Found location priors for {len(pose_priors)} images.")
+
+    coordinate_systems = {"UNKNOWN": -1, "WGS84": 0, "CARTESIAN": 1}
+    coordinate_system = coordinate_systems[
+        "CARTESIAN" if args.is_cartesian else "WGS84"
+    ]
+    db.create_pose_priors_table()
+    for image_id, position in pose_priors.items():
+        (exists,) = db.execute(
+            "SELECT COUNT(*) FROM pose_priors WHERE image_id = ?",
+            (image_id,),
+        ).fetchone()
+        if exists:
+            print(f"Location prior for {image_id} already exists, skipping.")
+            continue
+        db.add_pose_prior(image_id, position, coordinate_system)
+
+    if args.cleanup:
+        for col in ["qw", "qx", "qy", "qz", "tx", "ty", "tz"]:
+            db.execute(f"ALTER TABLE images DROP COLUMN prior_{col}")
+
+    db.commit()

scripts/python/nvm_to_ply.py

@@ -0,0 +1,133 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+# This script converts a VisualSfM reconstruction file to a PLY point cloud.
+
+import argparse
+
+import numpy as np
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--nvm_path", required=True)
+    parser.add_argument("--ply_path", required=True)
+    parser.add_argument("--normalize", type=bool, default=True)
+    parser.add_argument("--normalize_p0", type=float, default=0.2)
+    parser.add_argument("--normalize_p1", type=float, default=0.8)
+    parser.add_argument("--min_track_length", type=int, default=3)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    with open(args.nvm_path, "r") as fid:
+        fid.readline()
+        fid.readline()
+        num_images = int(fid.readline())
+
+        for i in range(num_images + 1):
+            fid.readline()
+
+        num_points = int(fid.readline())
+
+        xyz = np.zeros((num_points, 3), dtype=np.float64)
+        rgb = np.zeros((num_points, 3), dtype=np.uint16)
+        track_lengths = np.zeros((num_points,), dtype=np.uint32)
+
+        for i in range(num_points):
+            if i % 1000 == 0:
+                print("Reading point", i, "/", num_points)
+            elems = fid.readline().split()
+            xyz[i] = map(float, elems[0:3])
+            rgb[i] = map(int, elems[3:6])
+            track_lengths[i] = int(elems[6])
+
+    mask = track_lengths >= args.min_track_length
+    xyz = xyz[mask]
+    rgb = rgb[mask]
+
+    if args.normalize:
+        sorted_x = np.sort(xyz[:, 0])
+        sorted_y = np.sort(xyz[:, 1])
+        sorted_z = np.sort(xyz[:, 2])
+
+        num_coords = sorted_x.size
+        min_coord = int(args.normalize_p0 * num_coords)
+        max_coord = int(args.normalize_p1 * num_coords)
+        mean_coords = xyz.mean(0)
+
+        bbox_min = np.array(
+            [sorted_x[min_coord], sorted_y[min_coord], sorted_z[min_coord]]
+        )
+        bbox_max = np.array(
+            [sorted_x[max_coord], sorted_y[max_coord], sorted_z[max_coord]]
+        )
+
+        extent = np.linalg.norm(bbox_max - bbox_min)
+        scale = 10.0 / extent
+
+        xyz -= mean_coords
+        xyz *= scale
+
+    with open(args.ply_path, "w") as fid:
+        fid.write("ply\n")
+        fid.write("format ascii 1.0\n")
+        fid.write("element vertex %d\n" % xyz.shape[0])
+        fid.write("property float x\n")
+        fid.write("property float y\n")
+        fid.write("property float z\n")
+        fid.write("property float nx\n")
+        fid.write("property float ny\n")
+        fid.write("property float nz\n")
+        fid.write("property uchar diffuse_red\n")
+        fid.write("property uchar diffuse_green\n")
+        fid.write("property uchar diffuse_blue\n")
+        fid.write("end_header\n")
+        for i in range(xyz.shape[0]):
+            if i % 1000 == 0:
+                print("Writing point", i, "/", xyz.shape[0])
+            fid.write(
+                "%f %f %f 0 0 0 %d %d %d\n"
+                % (
+                    xyz[i, 0],
+                    xyz[i, 1],
+                    xyz[i, 2],
+                    rgb[i, 0],
+                    rgb[i, 1],
+                    rgb[i, 2],
+                )
+            )
+
+
+if __name__ == "__main__":
+    main()

scripts/python/read_write_dense.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import os
+import struct
+
+import numpy as np
+
+
+def read_array(path):
+    with open(path, "rb") as fid:
+        width, height, channels = np.genfromtxt(
+            fid, delimiter="&", max_rows=1, usecols=(0, 1, 2), dtype=int
+        )
+        fid.seek(0)
+        num_delimiter = 0
+        byte = fid.read(1)
+        while True:
+            if byte == b"&":
+                num_delimiter += 1
+                if num_delimiter >= 3:
+                    break
+            byte = fid.read(1)
+        array = np.fromfile(fid, np.float32)
+    array = array.reshape((width, height, channels), order="F")
+    return np.transpose(array, (1, 0, 2)).squeeze()
+
+
+def write_array(array, path):
+    """
+    see: src/mvs/mat.h
+        void Mat<T>::Write(const std::string& path)
+    """
+    assert array.dtype == np.float32
+    if len(array.shape) == 2:
+        height, width = array.shape
+        channels = 1
+    elif len(array.shape) == 3:
+        height, width, channels = array.shape
+    else:
+        assert False
+
+    with open(path, "w") as fid:
+        fid.write(str(width) + "&" + str(height) + "&" + str(channels) + "&")
+
+    with open(path, "ab") as fid:
+        if len(array.shape) == 2:
+            array_trans = np.transpose(array, (1, 0))
+        elif len(array.shape) == 3:
+            array_trans = np.transpose(array, (1, 0, 2))
+        else:
+            assert False
+        data_1d = array_trans.reshape(-1, order="F")
+        data_list = data_1d.tolist()
+        endian_character = "<"
+        format_char_sequence = "".join(["f"] * len(data_list))
+        byte_data = struct.pack(
+            endian_character + format_char_sequence, *data_list
+        )
+        fid.write(byte_data)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-d", "--depth_map", help="path to depth map", type=str, required=True
+    )
+    parser.add_argument(
+        "-n", "--normal_map", help="path to normal map", type=str, required=True
+    )
+    parser.add_argument(
+        "--min_depth_percentile",
+        help="minimum visualization depth percentile",
+        type=float,
+        default=5,
+    )
+    parser.add_argument(
+        "--max_depth_percentile",
+        help="maximum visualization depth percentile",
+        type=float,
+        default=95,
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    if args.min_depth_percentile > args.max_depth_percentile:
+        raise ValueError(
+            "min_depth_percentile should be less than or equal "
+            "to the max_depth_percentile."
+        )
+
+    # Read depth and normal maps corresponding to the same image.
+    if not os.path.exists(args.depth_map):
+        raise FileNotFoundError("File not found: {}".format(args.depth_map))
+
+    if not os.path.exists(args.normal_map):
+        raise FileNotFoundError("File not found: {}".format(args.normal_map))
+
+    depth_map = read_array(args.depth_map)
+    normal_map = read_array(args.normal_map)
+
+    min_depth, max_depth = np.percentile(
+        depth_map, [args.min_depth_percentile, args.max_depth_percentile]
+    )
+    depth_map[depth_map < min_depth] = min_depth
+    depth_map[depth_map > max_depth] = max_depth
+
+    import pylab as plt
+
+    # Visualize the depth map.
+    plt.figure()
+    plt.imshow(depth_map)
+    plt.title("depth map")
+
+    # Visualize the normal map.
+    plt.figure()
+    plt.imshow(normal_map)
+    plt.title("normal map")
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()

scripts/python/read_write_fused_vis.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import collections
+import os
+
+import numpy as np
+import pandas as pd
+from pyntcloud import PyntCloud
+from read_write_model import read_next_bytes, write_next_bytes
+
+MeshPoint = collections.namedtuple(
+    "MeshingPoint",
+    ["position", "color", "normal", "num_visible_images", "visible_image_idxs"],
+)
+
+
+def read_fused(path_to_fused_ply, path_to_fused_ply_vis):
+    """
+    see: src/mvs/meshing.cc
+        void ReadDenseReconstruction(const std::string& path
+    """
+    assert os.path.isfile(path_to_fused_ply)
+    assert os.path.isfile(path_to_fused_ply_vis)
+
+    point_cloud = PyntCloud.from_file(path_to_fused_ply)
+    xyz_arr = point_cloud.points.loc[:, ["x", "y", "z"]].to_numpy()
+    normal_arr = point_cloud.points.loc[:, ["nx", "ny", "nz"]].to_numpy()
+    color_arr = point_cloud.points.loc[:, ["red", "green", "blue"]].to_numpy()
+
+    with open(path_to_fused_ply_vis, "rb") as fid:
+        num_points = read_next_bytes(fid, 8, "Q")[0]
+        mesh_points = [0] * num_points
+        for i in range(num_points):
+            num_visible_images = read_next_bytes(fid, 4, "I")[0]
+            visible_image_idxs = read_next_bytes(
+                fid,
+                num_bytes=4 * num_visible_images,
+                format_char_sequence="I" * num_visible_images,
+            )
+            visible_image_idxs = np.array(tuple(map(int, visible_image_idxs)))
+            mesh_point = MeshPoint(
+                position=xyz_arr[i],
+                color=color_arr[i],
+                normal=normal_arr[i],
+                num_visible_images=num_visible_images,
+                visible_image_idxs=visible_image_idxs,
+            )
+            mesh_points[i] = mesh_point
+        return mesh_points
+
+
+def write_fused_ply(mesh_points, path_to_fused_ply):
+    columns = ["x", "y", "z", "nx", "ny", "nz", "red", "green", "blue"]
+    points_data_frame = pd.DataFrame(
+        np.zeros((len(mesh_points), len(columns))), columns=columns
+    )
+
+    positions = np.asarray([point.position for point in mesh_points])
+    normals = np.asarray([point.normal for point in mesh_points])
+    colors = np.asarray([point.color for point in mesh_points])
+
+    points_data_frame.loc[:, ["x", "y", "z"]] = positions
+    points_data_frame.loc[:, ["nx", "ny", "nz"]] = normals
+    points_data_frame.loc[:, ["red", "green", "blue"]] = colors
+
+    points_data_frame = points_data_frame.astype(
+        {
+            "x": positions.dtype,
+            "y": positions.dtype,
+            "z": positions.dtype,
+            "red": colors.dtype,
+            "green": colors.dtype,
+            "blue": colors.dtype,
+            "nx": normals.dtype,
+            "ny": normals.dtype,
+            "nz": normals.dtype,
+        }
+    )
+
+    point_cloud = PyntCloud(points_data_frame)
+    point_cloud.to_file(path_to_fused_ply)
+
+
+def write_fused_ply_vis(mesh_points, path_to_fused_ply_vis):
+    """
+    see: src/mvs/fusion.cc
+        void WritePointsVisibility(const std::string& path, const std::vector<std::vector<int>>& points_visibility)
+    """
+    with open(path_to_fused_ply_vis, "wb") as fid:
+        write_next_bytes(fid, len(mesh_points), "Q")
+        for point in mesh_points:
+            write_next_bytes(fid, point.num_visible_images, "I")
+            format_char_sequence = "I" * point.num_visible_images
+            write_next_bytes(
+                fid, [*point.visible_image_idxs], format_char_sequence
+            )
+
+
+def write_fused(points, path_to_fused_ply, path_to_fused_ply_vis):
+    write_fused_ply(points, path_to_fused_ply)
+    write_fused_ply_vis(points, path_to_fused_ply_vis)

scripts/python/read_write_model.py

@@ -0,0 +1,605 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import argparse
+import collections
+import os
+import struct
+
+import numpy as np
+
+CameraModel = collections.namedtuple(
+    "CameraModel", ["model_id", "model_name", "num_params"]
+)
+Camera = collections.namedtuple(
+    "Camera", ["id", "model", "width", "height", "params"]
+)
+BaseImage = collections.namedtuple(
+    "Image", ["id", "qvec", "tvec", "camera_id", "name", "xys", "point3D_ids"]
+)
+Point3D = collections.namedtuple(
+    "Point3D", ["id", "xyz", "rgb", "error", "image_ids", "point2D_idxs"]
+)
+
+
+class Image(BaseImage):
+    def qvec2rotmat(self):
+        return qvec2rotmat(self.qvec)
+
+
+CAMERA_MODELS = {
+    CameraModel(model_id=0, model_name="SIMPLE_PINHOLE", num_params=3),
+    CameraModel(model_id=1, model_name="PINHOLE", num_params=4),
+    CameraModel(model_id=2, model_name="SIMPLE_RADIAL", num_params=4),
+    CameraModel(model_id=3, model_name="RADIAL", num_params=5),
+    CameraModel(model_id=4, model_name="OPENCV", num_params=8),
+    CameraModel(model_id=5, model_name="OPENCV_FISHEYE", num_params=8),
+    CameraModel(model_id=6, model_name="FULL_OPENCV", num_params=12),
+    CameraModel(model_id=7, model_name="FOV", num_params=5),
+    CameraModel(model_id=8, model_name="SIMPLE_RADIAL_FISHEYE", num_params=4),
+    CameraModel(model_id=9, model_name="RADIAL_FISHEYE", num_params=5),
+    CameraModel(model_id=10, model_name="THIN_PRISM_FISHEYE", num_params=12),
+}
+CAMERA_MODEL_IDS = dict(
+    [(camera_model.model_id, camera_model) for camera_model in CAMERA_MODELS]
+)
+CAMERA_MODEL_NAMES = dict(
+    [(camera_model.model_name, camera_model) for camera_model in CAMERA_MODELS]
+)
+
+
+def read_next_bytes(fid, num_bytes, format_char_sequence, endian_character="<"):
+    """Read and unpack the next bytes from a binary file.
+    :param fid:
+    :param num_bytes: Sum of combination of {2, 4, 8}, e.g. 2, 6, 16, 30, etc.
+    :param format_char_sequence: List of {c, e, f, d, h, H, i, I, l, L, q, Q}.
+    :param endian_character: Any of {@, =, <, >, !}
+    :return: Tuple of read and unpacked values.
+    """
+    data = fid.read(num_bytes)
+    return struct.unpack(endian_character + format_char_sequence, data)
+
+
+def write_next_bytes(fid, data, format_char_sequence, endian_character="<"):
+    """pack and write to a binary file.
+    :param fid:
+    :param data: data to send, if multiple elements are sent at the same time,
+    they should be encapsuled either in a list or a tuple
+    :param format_char_sequence: List of {c, e, f, d, h, H, i, I, l, L, q, Q}.
+    should be the same length as the data list or tuple
+    :param endian_character: Any of {@, =, <, >, !}
+    """
+    if isinstance(data, (list, tuple)):
+        bytes = struct.pack(endian_character + format_char_sequence, *data)
+    else:
+        bytes = struct.pack(endian_character + format_char_sequence, data)
+    fid.write(bytes)
+
+
+def read_cameras_text(path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::WriteCamerasText(const std::string& path)
+        void Reconstruction::ReadCamerasText(const std::string& path)
+    """
+    cameras = {}
+    with open(path, "r") as fid:
+        while True:
+            line = fid.readline()
+            if not line:
+                break
+            line = line.strip()
+            if len(line) > 0 and line[0] != "#":
+                elems = line.split()
+                camera_id = int(elems[0])
+                model = elems[1]
+                width = int(elems[2])
+                height = int(elems[3])
+                params = np.array(tuple(map(float, elems[4:])))
+                cameras[camera_id] = Camera(
+                    id=camera_id,
+                    model=model,
+                    width=width,
+                    height=height,
+                    params=params,
+                )
+    return cameras
+
+
+def read_cameras_binary(path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::WriteCamerasBinary(const std::string& path)
+        void Reconstruction::ReadCamerasBinary(const std::string& path)
+    """
+    cameras = {}
+    with open(path_to_model_file, "rb") as fid:
+        num_cameras = read_next_bytes(fid, 8, "Q")[0]
+        for _ in range(num_cameras):
+            camera_properties = read_next_bytes(
+                fid, num_bytes=24, format_char_sequence="iiQQ"
+            )
+            camera_id = camera_properties[0]
+            model_id = camera_properties[1]
+            model_name = CAMERA_MODEL_IDS[camera_properties[1]].model_name
+            width = camera_properties[2]
+            height = camera_properties[3]
+            num_params = CAMERA_MODEL_IDS[model_id].num_params
+            params = read_next_bytes(
+                fid,
+                num_bytes=8 * num_params,
+                format_char_sequence="d" * num_params,
+            )
+            cameras[camera_id] = Camera(
+                id=camera_id,
+                model=model_name,
+                width=width,
+                height=height,
+                params=np.array(params),
+            )
+        assert len(cameras) == num_cameras
+    return cameras
+
+
+def write_cameras_text(cameras, path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::WriteCamerasText(const std::string& path)
+        void Reconstruction::ReadCamerasText(const std::string& path)
+    """
+    HEADER = (
+        "# Camera list with one line of data per camera:\n"
+        + "#   CAMERA_ID, MODEL, WIDTH, HEIGHT, PARAMS[]\n"
+        + "# Number of cameras: {}\n".format(len(cameras))
+    )
+    with open(path, "w") as fid:
+        fid.write(HEADER)
+        for _, cam in cameras.items():
+            to_write = [cam.id, cam.model, cam.width, cam.height, *cam.params]
+            line = " ".join([str(elem) for elem in to_write])
+            fid.write(line + "\n")
+
+
+def write_cameras_binary(cameras, path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::WriteCamerasBinary(const std::string& path)
+        void Reconstruction::ReadCamerasBinary(const std::string& path)
+    """
+    with open(path_to_model_file, "wb") as fid:
+        write_next_bytes(fid, len(cameras), "Q")
+        for _, cam in cameras.items():
+            model_id = CAMERA_MODEL_NAMES[cam.model].model_id
+            camera_properties = [cam.id, model_id, cam.width, cam.height]
+            write_next_bytes(fid, camera_properties, "iiQQ")
+            for p in cam.params:
+                write_next_bytes(fid, float(p), "d")
+    return cameras
+
+
+def read_images_text(path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadImagesText(const std::string& path)
+        void Reconstruction::WriteImagesText(const std::string& path)
+    """
+    images = {}
+    with open(path, "r") as fid:
+        while True:
+            line = fid.readline()
+            if not line:
+                break
+            line = line.strip()
+            if len(line) > 0 and line[0] != "#":
+                elems = line.split()
+                image_id = int(elems[0])
+                qvec = np.array(tuple(map(float, elems[1:5])))
+                tvec = np.array(tuple(map(float, elems[5:8])))
+                camera_id = int(elems[8])
+                image_name = elems[9]
+                elems = fid.readline().split()
+                xys = np.column_stack(
+                    [
+                        tuple(map(float, elems[0::3])),
+                        tuple(map(float, elems[1::3])),
+                    ]
+                )
+                point3D_ids = np.array(tuple(map(int, elems[2::3])))
+                images[image_id] = Image(
+                    id=image_id,
+                    qvec=qvec,
+                    tvec=tvec,
+                    camera_id=camera_id,
+                    name=image_name,
+                    xys=xys,
+                    point3D_ids=point3D_ids,
+                )
+    return images
+
+
+def read_images_binary(path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadImagesBinary(const std::string& path)
+        void Reconstruction::WriteImagesBinary(const std::string& path)
+    """
+    images = {}
+    with open(path_to_model_file, "rb") as fid:
+        num_reg_images = read_next_bytes(fid, 8, "Q")[0]
+        for _ in range(num_reg_images):
+            binary_image_properties = read_next_bytes(
+                fid, num_bytes=64, format_char_sequence="idddddddi"
+            )
+            image_id = binary_image_properties[0]
+            qvec = np.array(binary_image_properties[1:5])
+            tvec = np.array(binary_image_properties[5:8])
+            camera_id = binary_image_properties[8]
+            binary_image_name = b""
+            current_char = read_next_bytes(fid, 1, "c")[0]
+            while current_char != b"\x00":  # look for the ASCII 0 entry
+                binary_image_name += current_char
+                current_char = read_next_bytes(fid, 1, "c")[0]
+            image_name = binary_image_name.decode("utf-8")
+            num_points2D = read_next_bytes(
+                fid, num_bytes=8, format_char_sequence="Q"
+            )[0]
+            x_y_id_s = read_next_bytes(
+                fid,
+                num_bytes=24 * num_points2D,
+                format_char_sequence="ddq" * num_points2D,
+            )
+            xys = np.column_stack(
+                [
+                    tuple(map(float, x_y_id_s[0::3])),
+                    tuple(map(float, x_y_id_s[1::3])),
+                ]
+            )
+            point3D_ids = np.array(tuple(map(int, x_y_id_s[2::3])))
+            images[image_id] = Image(
+                id=image_id,
+                qvec=qvec,
+                tvec=tvec,
+                camera_id=camera_id,
+                name=image_name,
+                xys=xys,
+                point3D_ids=point3D_ids,
+            )
+    return images
+
+
+def write_images_text(images, path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadImagesText(const std::string& path)
+        void Reconstruction::WriteImagesText(const std::string& path)
+    """
+    if len(images) == 0:
+        mean_observations = 0
+    else:
+        mean_observations = sum(
+            (len(img.point3D_ids) for _, img in images.items())
+        ) / len(images)
+    HEADER = (
+        "# Image list with two lines of data per image:\n"
+        + "#   IMAGE_ID, QW, QX, QY, QZ, TX, TY, TZ, CAMERA_ID, NAME\n"
+        + "#   POINTS2D[] as (X, Y, POINT3D_ID)\n"
+        + "# Number of images: {}, mean observations per image: {}\n".format(
+            len(images), mean_observations
+        )
+    )
+
+    with open(path, "w") as fid:
+        fid.write(HEADER)
+        for _, img in images.items():
+            image_header = [
+                img.id,
+                *img.qvec,
+                *img.tvec,
+                img.camera_id,
+                img.name,
+            ]
+            first_line = " ".join(map(str, image_header))
+            fid.write(first_line + "\n")
+
+            points_strings = []
+            for xy, point3D_id in zip(img.xys, img.point3D_ids):
+                points_strings.append(" ".join(map(str, [*xy, point3D_id])))
+            fid.write(" ".join(points_strings) + "\n")
+
+
+def write_images_binary(images, path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadImagesBinary(const std::string& path)
+        void Reconstruction::WriteImagesBinary(const std::string& path)
+    """
+    with open(path_to_model_file, "wb") as fid:
+        write_next_bytes(fid, len(images), "Q")
+        for _, img in images.items():
+            write_next_bytes(fid, img.id, "i")
+            write_next_bytes(fid, img.qvec.tolist(), "dddd")
+            write_next_bytes(fid, img.tvec.tolist(), "ddd")
+            write_next_bytes(fid, img.camera_id, "i")
+            for char in img.name:
+                write_next_bytes(fid, char.encode("utf-8"), "c")
+            write_next_bytes(fid, b"\x00", "c")
+            write_next_bytes(fid, len(img.point3D_ids), "Q")
+            for xy, p3d_id in zip(img.xys, img.point3D_ids):
+                write_next_bytes(fid, [*xy, p3d_id], "ddq")
+
+
+def read_points3D_text(path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadPoints3DText(const std::string& path)
+        void Reconstruction::WritePoints3DText(const std::string& path)
+    """
+    points3D = {}
+    with open(path, "r") as fid:
+        while True:
+            line = fid.readline()
+            if not line:
+                break
+            line = line.strip()
+            if len(line) > 0 and line[0] != "#":
+                elems = line.split()
+                point3D_id = int(elems[0])
+                xyz = np.array(tuple(map(float, elems[1:4])))
+                rgb = np.array(tuple(map(int, elems[4:7])))
+                error = float(elems[7])
+                image_ids = np.array(tuple(map(int, elems[8::2])))
+                point2D_idxs = np.array(tuple(map(int, elems[9::2])))
+                points3D[point3D_id] = Point3D(
+                    id=point3D_id,
+                    xyz=xyz,
+                    rgb=rgb,
+                    error=error,
+                    image_ids=image_ids,
+                    point2D_idxs=point2D_idxs,
+                )
+    return points3D
+
+
+def read_points3D_binary(path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadPoints3DBinary(const std::string& path)
+        void Reconstruction::WritePoints3DBinary(const std::string& path)
+    """
+    points3D = {}
+    with open(path_to_model_file, "rb") as fid:
+        num_points = read_next_bytes(fid, 8, "Q")[0]
+        for _ in range(num_points):
+            binary_point_line_properties = read_next_bytes(
+                fid, num_bytes=43, format_char_sequence="QdddBBBd"
+            )
+            point3D_id = binary_point_line_properties[0]
+            xyz = np.array(binary_point_line_properties[1:4])
+            rgb = np.array(binary_point_line_properties[4:7])
+            error = np.array(binary_point_line_properties[7])
+            track_length = read_next_bytes(
+                fid, num_bytes=8, format_char_sequence="Q"
+            )[0]
+            track_elems = read_next_bytes(
+                fid,
+                num_bytes=8 * track_length,
+                format_char_sequence="ii" * track_length,
+            )
+            image_ids = np.array(tuple(map(int, track_elems[0::2])))
+            point2D_idxs = np.array(tuple(map(int, track_elems[1::2])))
+            points3D[point3D_id] = Point3D(
+                id=point3D_id,
+                xyz=xyz,
+                rgb=rgb,
+                error=error,
+                image_ids=image_ids,
+                point2D_idxs=point2D_idxs,
+            )
+    return points3D
+
+
+def write_points3D_text(points3D, path):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadPoints3DText(const std::string& path)
+        void Reconstruction::WritePoints3DText(const std::string& path)
+    """
+    if len(points3D) == 0:
+        mean_track_length = 0
+    else:
+        mean_track_length = sum(
+            (len(pt.image_ids) for _, pt in points3D.items())
+        ) / len(points3D)
+    HEADER = (
+        "# 3D point list with one line of data per point:\n"
+        + "#   POINT3D_ID, X, Y, Z, R, G, B, ERROR, TRACK[] as (IMAGE_ID, POINT2D_IDX)\n"
+        + "# Number of points: {}, mean track length: {}\n".format(
+            len(points3D), mean_track_length
+        )
+    )
+
+    with open(path, "w") as fid:
+        fid.write(HEADER)
+        for _, pt in points3D.items():
+            point_header = [pt.id, *pt.xyz, *pt.rgb, pt.error]
+            fid.write(" ".join(map(str, point_header)) + " ")
+            track_strings = []
+            for image_id, point2D in zip(pt.image_ids, pt.point2D_idxs):
+                track_strings.append(" ".join(map(str, [image_id, point2D])))
+            fid.write(" ".join(track_strings) + "\n")
+
+
+def write_points3D_binary(points3D, path_to_model_file):
+    """
+    see: src/colmap/scene/reconstruction.cc
+        void Reconstruction::ReadPoints3DBinary(const std::string& path)
+        void Reconstruction::WritePoints3DBinary(const std::string& path)
+    """
+    with open(path_to_model_file, "wb") as fid:
+        write_next_bytes(fid, len(points3D), "Q")
+        for _, pt in points3D.items():
+            write_next_bytes(fid, pt.id, "Q")
+            write_next_bytes(fid, pt.xyz.tolist(), "ddd")
+            write_next_bytes(fid, pt.rgb.tolist(), "BBB")
+            write_next_bytes(fid, pt.error, "d")
+            track_length = pt.image_ids.shape[0]
+            write_next_bytes(fid, track_length, "Q")
+            for image_id, point2D_id in zip(pt.image_ids, pt.point2D_idxs):
+                write_next_bytes(fid, [image_id, point2D_id], "ii")
+
+
+def detect_model_format(path, ext):
+    if (
+        os.path.isfile(os.path.join(path, "cameras" + ext))
+        and os.path.isfile(os.path.join(path, "images" + ext))
+        and os.path.isfile(os.path.join(path, "points3D" + ext))
+    ):
+        print("Detected model format: '" + ext + "'")
+        return True
+
+    return False
+
+
+def read_model(path, ext=""):
+    # try to detect the extension automatically
+    if ext == "":
+        if detect_model_format(path, ".bin"):
+            ext = ".bin"
+        elif detect_model_format(path, ".txt"):
+            ext = ".txt"
+        else:
+            print("Provide model format: '.bin' or '.txt'")
+            return
+
+    if ext == ".txt":
+        cameras = read_cameras_text(os.path.join(path, "cameras" + ext))
+        images = read_images_text(os.path.join(path, "images" + ext))
+        points3D = read_points3D_text(os.path.join(path, "points3D") + ext)
+    else:
+        cameras = read_cameras_binary(os.path.join(path, "cameras" + ext))
+        images = read_images_binary(os.path.join(path, "images" + ext))
+        points3D = read_points3D_binary(os.path.join(path, "points3D") + ext)
+    return cameras, images, points3D
+
+
+def write_model(cameras, images, points3D, path, ext=".bin"):
+    if ext == ".txt":
+        write_cameras_text(cameras, os.path.join(path, "cameras" + ext))
+        write_images_text(images, os.path.join(path, "images" + ext))
+        write_points3D_text(points3D, os.path.join(path, "points3D") + ext)
+    else:
+        write_cameras_binary(cameras, os.path.join(path, "cameras" + ext))
+        write_images_binary(images, os.path.join(path, "images" + ext))
+        write_points3D_binary(points3D, os.path.join(path, "points3D") + ext)
+    return cameras, images, points3D
+
+
+def qvec2rotmat(qvec):
+    return np.array(
+        [
+            [
+                1 - 2 * qvec[2] ** 2 - 2 * qvec[3] ** 2,
+                2 * qvec[1] * qvec[2] - 2 * qvec[0] * qvec[3],
+                2 * qvec[3] * qvec[1] + 2 * qvec[0] * qvec[2],
+            ],
+            [
+                2 * qvec[1] * qvec[2] + 2 * qvec[0] * qvec[3],
+                1 - 2 * qvec[1] ** 2 - 2 * qvec[3] ** 2,
+                2 * qvec[2] * qvec[3] - 2 * qvec[0] * qvec[1],
+            ],
+            [
+                2 * qvec[3] * qvec[1] - 2 * qvec[0] * qvec[2],
+                2 * qvec[2] * qvec[3] + 2 * qvec[0] * qvec[1],
+                1 - 2 * qvec[1] ** 2 - 2 * qvec[2] ** 2,
+            ],
+        ]
+    )
+
+
+def rotmat2qvec(R):
+    Rxx, Ryx, Rzx, Rxy, Ryy, Rzy, Rxz, Ryz, Rzz = R.flat
+    K = (
+        np.array(
+            [
+                [Rxx - Ryy - Rzz, 0, 0, 0],
+                [Ryx + Rxy, Ryy - Rxx - Rzz, 0, 0],
+                [Rzx + Rxz, Rzy + Ryz, Rzz - Rxx - Ryy, 0],
+                [Ryz - Rzy, Rzx - Rxz, Rxy - Ryx, Rxx + Ryy + Rzz],
+            ]
+        )
+        / 3.0
+    )
+    eigvals, eigvecs = np.linalg.eigh(K)
+    qvec = eigvecs[[3, 0, 1, 2], np.argmax(eigvals)]
+    if qvec[0] < 0:
+        qvec *= -1
+    return qvec
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Read and write COLMAP binary and text models"
+    )
+    parser.add_argument("--input_model", help="path to input model folder")
+    parser.add_argument(
+        "--input_format",
+        choices=[".bin", ".txt"],
+        help="input model format",
+        default="",
+    )
+    parser.add_argument("--output_model", help="path to output model folder")
+    parser.add_argument(
+        "--output_format",
+        choices=[".bin", ".txt"],
+        help="output model format",
+        default=".txt",
+    )
+    args = parser.parse_args()
+
+    cameras, images, points3D = read_model(
+        path=args.input_model, ext=args.input_format
+    )
+
+    print("num_cameras:", len(cameras))
+    print("num_images:", len(images))
+    print("num_points3D:", len(points3D))
+
+    if args.output_model is not None:
+        write_model(
+            cameras,
+            images,
+            points3D,
+            path=args.output_model,
+            ext=args.output_format,
+        )
+
+
+if __name__ == "__main__":
+    main()

scripts/python/test_read_write_dense.py

@@ -0,0 +1,65 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import numpy as np
+from read_write_dense import read_array, write_array
+
+
+def main():
+    import sys
+
+    if len(sys.argv) != 3:
+        print(
+            "Usage: python test_read_write_dense.py "
+            "path/to/dense/input.bin path/to/dense/output.bin"
+        )
+        return
+
+    print(
+        "Checking consistency of reading and writing dense arrays "
+        + "(depth maps / normal maps) ..."
+    )
+
+    path_to_dense_input = sys.argv[1]
+    path_to_dense_output = sys.argv[2]
+
+    dense_input = read_array(path_to_dense_input)
+    print("Input shape: " + str(dense_input.shape))
+
+    write_array(dense_input, path_to_dense_output)
+    dense_output = read_array(path_to_dense_output)
+
+    np.testing.assert_array_equal(dense_input, dense_output)
+
+    print("... dense arrays are equal.")
+
+
+if __name__ == "__main__":
+    main()

scripts/python/test_read_write_fused_vis.py

@@ -0,0 +1,72 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+import filecmp
+
+from read_write_fused_vis import read_fused, write_fused
+
+
+def main():
+    import sys
+
+    if len(sys.argv) != 5:
+        print(
+            "Usage: python test_read_write_fused_vis.py "
+            "path/to/input_fused.ply path/to/input_fused.ply.vis "
+            "path/to/output_fused.ply path/to/output_fused.ply.vis"
+        )
+        return
+
+    print(
+        "Checking consistency of reading and writing fused.ply and fused.ply.vis files ..."
+    )
+
+    path_to_fused_ply_input = sys.argv[1]
+    path_to_fused_ply_vis_input = sys.argv[2]
+    path_to_fused_ply_output = sys.argv[3]
+    path_to_fused_ply_vis_output = sys.argv[4]
+
+    mesh_points = read_fused(
+        path_to_fused_ply_input, path_to_fused_ply_vis_input
+    )
+    write_fused(
+        mesh_points, path_to_fused_ply_output, path_to_fused_ply_vis_output
+    )
+
+    assert filecmp.cmp(path_to_fused_ply_input, path_to_fused_ply_output)
+    assert filecmp.cmp(
+        path_to_fused_ply_vis_input, path_to_fused_ply_vis_output
+    )
+
+    print("... Results are equal.")
+
+
+if __name__ == "__main__":
+    main()

scripts/python/test_read_write_model.py

@@ -0,0 +1,121 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+from tempfile import mkdtemp
+
+import numpy as np
+from read_write_model import read_model, write_model
+
+
+def compare_cameras(cameras1, cameras2):
+    assert len(cameras1) == len(cameras2)
+    for camera_id1 in cameras1:
+        camera1 = cameras1[camera_id1]
+        camera2 = cameras2[camera_id1]
+        assert camera1.id == camera2.id
+        assert camera1.width == camera2.width
+        assert camera1.height == camera2.height
+        assert np.allclose(camera1.params, camera2.params)
+
+
+def compare_images(images1, images2):
+    assert len(images1) == len(images2)
+    for image_id1 in images1:
+        image1 = images1[image_id1]
+        image2 = images2[image_id1]
+        assert image1.id == image2.id
+        assert np.allclose(image1.qvec, image2.qvec)
+        assert np.allclose(image1.tvec, image2.tvec)
+        assert image1.camera_id == image2.camera_id
+        assert image1.name == image2.name
+        assert np.allclose(image1.xys, image2.xys)
+        assert np.array_equal(image1.point3D_ids, image2.point3D_ids)
+
+
+def compare_points(points3D1, points3D2):
+    for point3D_id1 in points3D1:
+        point3D1 = points3D1[point3D_id1]
+        point3D2 = points3D2[point3D_id1]
+        assert point3D1.id == point3D2.id
+        assert np.allclose(point3D1.xyz, point3D2.xyz)
+        assert np.array_equal(point3D1.rgb, point3D2.rgb)
+        assert np.allclose(point3D1.error, point3D2.error)
+        assert np.array_equal(point3D1.image_ids, point3D2.image_ids)
+        assert np.array_equal(point3D1.point2D_idxs, point3D2.point2D_idxs)
+
+
+def main():
+    import sys
+
+    if len(sys.argv) != 3:
+        print(
+            "Usage: python read_model.py "
+            "path/to/model/folder/txt path/to/model/folder/bin"
+        )
+        return
+
+    print("Comparing text and binary models ...")
+
+    path_to_model_txt_folder = sys.argv[1]
+    path_to_model_bin_folder = sys.argv[2]
+    cameras_txt, images_txt, points3D_txt = read_model(
+        path_to_model_txt_folder, ext=".txt"
+    )
+    cameras_bin, images_bin, points3D_bin = read_model(
+        path_to_model_bin_folder, ext=".bin"
+    )
+    compare_cameras(cameras_txt, cameras_bin)
+    compare_images(images_txt, images_bin)
+    compare_points(points3D_txt, points3D_bin)
+
+    print("... text and binary models are equal.")
+    print("Saving text model and reloading it ...")
+
+    tmpdir = mkdtemp()
+    write_model(cameras_bin, images_bin, points3D_bin, tmpdir, ext=".txt")
+    cameras_txt, images_txt, points3D_txt = read_model(tmpdir, ext=".txt")
+    compare_cameras(cameras_txt, cameras_bin)
+    compare_images(images_txt, images_bin)
+    compare_points(points3D_txt, points3D_bin)
+
+    print("... saved text and loaded models are equal.")
+    print("Saving binary model and reloading it ...")
+
+    write_model(cameras_bin, images_bin, points3D_bin, tmpdir, ext=".bin")
+    cameras_bin, images_bin, points3D_bin = read_model(tmpdir, ext=".bin")
+    compare_cameras(cameras_txt, cameras_bin)
+    compare_images(images_txt, images_bin)
+    compare_points(points3D_txt, points3D_bin)
+
+    print("... saved binary and loaded models are equal.")
+
+
+if __name__ == "__main__":
+    main()

scripts/python/visualize_model.py

@@ -0,0 +1,233 @@
+# Copyright (c), ETH Zurich and UNC Chapel Hill.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
+#       its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+import argparse
+
+import numpy as np
+import open3d
+from read_write_model import qvec2rotmat, read_model
+
+
+class Model:
+    def __init__(self):
+        self.cameras = []
+        self.images = []
+        self.points3D = []
+        self.__vis = None
+
+    def read_model(self, path, ext=""):
+        self.cameras, self.images, self.points3D = read_model(path, ext)
+
+    def add_points(self, min_track_len=3, remove_statistical_outlier=True):
+        pcd = open3d.geometry.PointCloud()
+
+        xyz = []
+        rgb = []
+        for point3D in self.points3D.values():
+            track_len = len(point3D.point2D_idxs)
+            if track_len < min_track_len:
+                continue
+            xyz.append(point3D.xyz)
+            rgb.append(point3D.rgb / 255)
+
+        pcd.points = open3d.utility.Vector3dVector(xyz)
+        pcd.colors = open3d.utility.Vector3dVector(rgb)
+
+        # remove obvious outliers
+        if remove_statistical_outlier:
+            [pcd, _] = pcd.remove_statistical_outlier(
+                nb_neighbors=20, std_ratio=2.0
+            )
+
+        # open3d.visualization.draw_geometries([pcd])
+        self.__vis.add_geometry(pcd)
+        self.__vis.poll_events()
+        self.__vis.update_renderer()
+
+    def add_cameras(self, scale=1):
+        frames = []
+        for img in self.images.values():
+            # rotation
+            R = qvec2rotmat(img.qvec)
+
+            # translation
+            t = img.tvec
+
+            # invert
+            t = -R.T @ t
+            R = R.T
+
+            # intrinsics
+            cam = self.cameras[img.camera_id]
+
+            if cam.model in ("SIMPLE_PINHOLE", "SIMPLE_RADIAL", "RADIAL"):
+                fx = fy = cam.params[0]
+                cx = cam.params[1]
+                cy = cam.params[2]
+            elif cam.model in (
+                "PINHOLE",
+                "OPENCV",
+                "OPENCV_FISHEYE",
+                "FULL_OPENCV",
+            ):
+                fx = cam.params[0]
+                fy = cam.params[1]
+                cx = cam.params[2]
+                cy = cam.params[3]
+            else:
+                raise Exception("Camera model not supported")
+
+            # intrinsics
+            K = np.identity(3)
+            K[0, 0] = fx
+            K[1, 1] = fy
+            K[0, 2] = cx
+            K[1, 2] = cy
+
+            # create axis, plane and pyramed geometries that will be drawn
+            cam_model = draw_camera(K, R, t, cam.width, cam.height, scale)
+            frames.extend(cam_model)
+
+        # add geometries to visualizer
+        for i in frames:
+            self.__vis.add_geometry(i)
+
+    def create_window(self):
+        self.__vis = open3d.visualization.Visualizer()
+        self.__vis.create_window()
+
+    def show(self):
+        self.__vis.poll_events()
+        self.__vis.update_renderer()
+        self.__vis.run()
+        self.__vis.destroy_window()
+
+
+def draw_camera(K, R, t, w, h, scale=1, color=[0.8, 0.2, 0.8]):
+    """Create axis, plane and pyramed geometries in Open3D format.
+    :param K: calibration matrix (camera intrinsics)
+    :param R: rotation matrix
+    :param t: translation
+    :param w: image width
+    :param h: image height
+    :param scale: camera model scale
+    :param color: color of the image plane and pyramid lines
+    :return: camera model geometries (axis, plane and pyramid)
+    """
+
+    # intrinsics
+    K = K.copy() / scale
+    Kinv = np.linalg.inv(K)
+
+    # 4x4 transformation
+    T = np.column_stack((R, t))
+    T = np.vstack((T, (0, 0, 0, 1)))
+
+    # axis
+    axis = open3d.geometry.TriangleMesh.create_coordinate_frame(
+        size=0.5 * scale
+    )
+    axis.transform(T)
+
+    # points in pixel
+    points_pixel = [
+        [0, 0, 0],
+        [0, 0, 1],
+        [w, 0, 1],
+        [0, h, 1],
+        [w, h, 1],
+    ]
+
+    # pixel to camera coordinate system
+    points = [Kinv @ p for p in points_pixel]
+
+    # image plane
+    width = abs(points[1][0]) + abs(points[3][0])
+    height = abs(points[1][1]) + abs(points[3][1])
+    plane = open3d.geometry.TriangleMesh.create_box(width, height, depth=1e-6)
+    plane.paint_uniform_color(color)
+    plane.translate([points[1][0], points[1][1], scale])
+    plane.transform(T)
+
+    # pyramid
+    points_in_world = [(R @ p + t) for p in points]
+    lines = [
+        [0, 1],
+        [0, 2],
+        [0, 3],
+        [0, 4],
+    ]
+    colors = [color for i in range(len(lines))]
+    line_set = open3d.geometry.LineSet(
+        points=open3d.utility.Vector3dVector(points_in_world),
+        lines=open3d.utility.Vector2iVector(lines),
+    )
+    line_set.colors = open3d.utility.Vector3dVector(colors)
+
+    # return as list in Open3D format
+    return [axis, plane, line_set]
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Visualize COLMAP binary and text models"
+    )
+    parser.add_argument(
+        "--input_model", required=True, help="path to input model folder"
+    )
+    parser.add_argument(
+        "--input_format",
+        choices=[".bin", ".txt"],
+        help="input model format",
+        default="",
+    )
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # read COLMAP model
+    model = Model()
+    model.read_model(args.input_model, ext=args.input_format)
+
+    print("num_cameras:", len(model.cameras))
+    print("num_images:", len(model.images))
+    print("num_points3D:", len(model.points3D))
+
+    # display using Open3D visualization tools
+    model.create_window()
+    model.add_points()
+    model.add_cameras(scale=0.25)
+    model.show()
+
+
+if __name__ == "__main__":
+    main()