SLACOptimizer.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <string>
#include <vector>
 
#include "cloudViewer/pipelines/registration/PoseGraph.h"
#include "cloudViewer/t/pipelines/slac/ControlGrid.h"
#include "cloudViewer/t/pipelines/slac/Visualization.h"
 
namespace cloudViewer {
namespace t {
namespace pipelines {
namespace slac {
 
using PoseGraph = cloudViewer::pipelines::registration::PoseGraph;
 
struct SLACOptimizerParams {
    int max_iterations_;
 
    float voxel_size_;
 
    float distance_threshold_;
 
    float fitness_threshold_;
 
    float regularizer_weight_;
 
    core::Device device_;
 
    std::string slac_folder_ = "";
    std::string GetSubfolderName() const {
        if (voxel_size_ < 0) {
            return fmt::format("{}/original", slac_folder_);
        }
        return fmt::format("{}/{:.3f}", slac_folder_, voxel_size_);
    }
 
    SLACOptimizerParams(const int max_iterations = 5,
                        const float voxel_size = 0.05,
                        const float distance_threshold = 0.07,
                        const float fitness_threshold = 0.3,
                        const float regularizer_weight = 1,
                        const core::Device device = core::Device("CPU:0"),
                        const std::string slac_folder = "") {
        if (fitness_threshold < 0) {
            utility::LogError("fitness threshold must be positive.");
        }
        if (distance_threshold < 0) {
            utility::LogError("distance threshold must be positive.");
        }
 
        max_iterations_ = max_iterations;
        voxel_size_ = voxel_size;
        distance_threshold_ = distance_threshold;
        fitness_threshold_ = fitness_threshold;
        regularizer_weight_ = regularizer_weight;
        device_ = device;
        slac_folder_ = slac_folder;
    }
};
 
struct SLACDebugOption {
    bool debug_ = false;
 
    int debug_start_node_idx_ = 0;
 
    SLACDebugOption(const bool debug = false,
                    const int debug_start_node_idx = 0) {
        if (debug_start_node_idx < 0) {
            utility::LogError("debug_start_node_idx must be positive integer.");
        }
 
        debug_ = debug;
        debug_start_node_idx_ = debug_start_node_idx;
    }
 
    SLACDebugOption(const int debug_start_node_idx) {
        if (debug_start_node_idx < 0) {
            utility::LogError("debug_start_node_idx must be positive integer.");
        }
 
        debug_ = true;
        debug_start_node_idx_ = debug_start_node_idx;
    }
};
 
void SaveCorrespondencesForPointClouds(
        const std::vector<std::string>& fnames_processed,
        const PoseGraph& fragment_pose_graph,
        const SLACOptimizerParams& params = SLACOptimizerParams(),
        const SLACDebugOption& debug_option = SLACDebugOption());
 
std::pair<PoseGraph, ControlGrid> RunSLACOptimizerForFragments(
        const std::vector<std::string>& fragment_filenames,
        const PoseGraph& fragment_pose_graph,
        const SLACOptimizerParams& params = SLACOptimizerParams(),
        const SLACDebugOption& debug_option = SLACDebugOption());
 
PoseGraph RunRigidOptimizerForFragments(
        const std::vector<std::string>& fragment_filenames,
        const PoseGraph& fragment_pose_graph,
        const SLACOptimizerParams& params = SLACOptimizerParams(),
        const SLACDebugOption& debug_option = SLACDebugOption());
 
}  // namespace slac
}  // namespace pipelines
}  // namespace t
}  // namespace cloudViewer