LocalPointCloudRegistrationParameters.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of the Zivid API
 *
 * Copyright 2015-2025 (C) Zivid AS
 * All rights reserved.
 *
 * Zivid Software License, v1.0
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * 4. This software, with or without modification, must not be used with any
 * other 3D camera than from Zivid AS.
 *
 * 5. Any software provided in binary form under this license must not be
 * reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS 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.
 *
 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/DataModel/Detail/Detail.h"
#include "Zivid/DataModel/NodeType.h"
#include "Zivid/DataModel/Traits.h"
#include "Zivid/Detail/CoreExport.h"
#include "Zivid/Detail/TypeTraits.h"
#include "Zivid/Range.h"
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
#endif
 
namespace Zivid
{
    namespace Experimental
    {
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT LocalPointCloudRegistrationParameters
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "" };
 
            static constexpr const char *name{ "LocalPointCloudRegistrationParameters" };
 
            static constexpr const char *description{
                R"description(Input parameters for controlling the local point cloud registration process.
)description"
            };
 
            static constexpr size_t version{ 1 };
 
#ifndef NO_DOC
            template<size_t>
            struct Version;
 
            using LatestVersion = Zivid::Experimental::LocalPointCloudRegistrationParameters;
 
            // Short identifier. This value is not guaranteed to be universally unique
            // Todo(ZIVID-2808): Move this to internal DataModelExt header
            static constexpr std::array<uint8_t, 3> binaryId{ 'l', 'p', 'r' };
 
#endif
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT ConvergenceCriteria
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "ConvergenceCriteria" };
 
                static constexpr const char *name{ "ConvergenceCriteria" };
 
                static constexpr const char *description{
                    R"description(Criteria for ending iteration early. Iteration will end when all criteria are satisfied.
)description"
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT RMSEDiffThreshold
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "ConvergenceCriteria/RMSEDiffThreshold" };
 
                    static constexpr const char *name{ "RMSEDiffThreshold" };
 
                    static constexpr const char *description{
                        R"description(Stop iteration when the absolute change in root mean square error (RMSE) from previous iteration is less than this threshold.
RMSE is defined as the square root of the average squared distance between corresponding points in the source and target point clouds.
)description"
                    };
 
                    using ValueType = float;
 
                    static constexpr Range<float> validRange()
                    {
                        return { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
                    }
 
                    RMSEDiffThreshold() = default;
 
                    explicit constexpr RMSEDiffThreshold(float value)
                        : m_value{ value }
                    {}
 
                    float value() const;
 
                    std::string toString() const;
 
                    bool operator==(const RMSEDiffThreshold &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const RMSEDiffThreshold &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const RMSEDiffThreshold &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const RMSEDiffThreshold &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    bool operator<=(const RMSEDiffThreshold &other) const
                    {
                        return m_value <= other.m_value;
                    }
 
                    bool operator>=(const RMSEDiffThreshold &other) const
                    {
                        return m_value >= other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const RMSEDiffThreshold &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    float m_value{ 1e-4F };
 
                    friend struct DataModel::Detail::Befriend<RMSEDiffThreshold>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT SourceCoverageDiffThreshold
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "ConvergenceCriteria/SourceCoverageDiffThreshold" };
 
                    static constexpr const char *name{ "SourceCoverageDiffThreshold" };
 
                    static constexpr const char *description{
                        R"description(Stop iteration when the absolute change in coverage from previous iteration is less than this threshold.
Coverage is defined as the fraction of points in the source point cloud that found a correspondence in the target point cloud.
)description"
                    };
 
                    using ValueType = float;
 
                    static constexpr Range<float> validRange()
                    {
                        return { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
                    }
 
                    SourceCoverageDiffThreshold() = default;
 
                    explicit constexpr SourceCoverageDiffThreshold(float value)
                        : m_value{ value }
                    {}
 
                    float value() const;
 
                    std::string toString() const;
 
                    bool operator==(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    bool operator<=(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value <= other.m_value;
                    }
 
                    bool operator>=(const SourceCoverageDiffThreshold &other) const
                    {
                        return m_value >= other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const SourceCoverageDiffThreshold &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    float m_value{ 1e-4F };
 
                    friend struct DataModel::Detail::Befriend<SourceCoverageDiffThreshold>;
                };
 
                using Descendants = std::tuple<
                    LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold,
                    LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold>;
 
                ConvergenceCriteria();
 
#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit ConvergenceCriteria(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to ConvergenceCriteria(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }
 
#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }
 
#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                ConvergenceCriteria copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }
 
                const RMSEDiffThreshold &rmseDiffThreshold() const
                {
                    return m_rmseDiffThreshold;
                }
 
                RMSEDiffThreshold &rmseDiffThreshold()
                {
                    return m_rmseDiffThreshold;
                }
 
                ConvergenceCriteria &set(const RMSEDiffThreshold &value)
                {
                    m_rmseDiffThreshold = value;
                    return *this;
                }
 
                const SourceCoverageDiffThreshold &sourceCoverageDiffThreshold() const
                {
                    return m_sourceCoverageDiffThreshold;
                }
 
                SourceCoverageDiffThreshold &sourceCoverageDiffThreshold()
                {
                    return m_sourceCoverageDiffThreshold;
                }
 
                ConvergenceCriteria &set(const SourceCoverageDiffThreshold &value)
                {
                    m_sourceCoverageDiffThreshold = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold>::
                            value,
                        int>::type = 0>
                const LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold &get() const
                {
                    return m_rmseDiffThreshold;
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<
                            T,
                            LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold>::
                            value,
                        int>::type = 0>
                const LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold &get()
                    const
                {
                    return m_sourceCoverageDiffThreshold;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold &get() const
                {
                    return m_rmseDiffThreshold;
                }
 
                template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                const LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold &get()
                    const
                {
                    return m_sourceCoverageDiffThreshold;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_rmseDiffThreshold);
                    f(m_sourceCoverageDiffThreshold);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_rmseDiffThreshold);
                    f(m_sourceCoverageDiffThreshold);
                }
 
                bool operator==(const ConvergenceCriteria &other) const;
 
                bool operator!=(const ConvergenceCriteria &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const ConvergenceCriteria &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                RMSEDiffThreshold m_rmseDiffThreshold;
                SourceCoverageDiffThreshold m_sourceCoverageDiffThreshold;
 
                friend struct DataModel::Detail::Befriend<ConvergenceCriteria>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT MaxCorrespondenceDistance
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "MaxCorrespondenceDistance" };
 
                static constexpr const char *name{ "MaxCorrespondenceDistance" };
 
                static constexpr const char *description{
                    R"description(The radius around each source point in which the algorithm will look for neighbors in the target point cloud.
Should be larger than the typical distance between points in the point clouds.
This parameter may have a significant performance impact.
)description"
                };
 
                using ValueType = float;
 
                static constexpr Range<float> validRange()
                {
                    return { std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max() };
                }
 
                MaxCorrespondenceDistance() = default;
 
                explicit constexpr MaxCorrespondenceDistance(float value)
                    : m_value{ value }
                {}
 
                float value() const;
 
                std::string toString() const;
 
                bool operator==(const MaxCorrespondenceDistance &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const MaxCorrespondenceDistance &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const MaxCorrespondenceDistance &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const MaxCorrespondenceDistance &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const MaxCorrespondenceDistance &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const MaxCorrespondenceDistance &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const MaxCorrespondenceDistance &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                float m_value{ 10.0F };
 
                friend struct DataModel::Detail::Befriend<MaxCorrespondenceDistance>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT MaxIterationCount
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "MaxIterationCount" };
 
                static constexpr const char *name{ "MaxIterationCount" };
 
                static constexpr const char *description{
                    R"description(End iteration when reaching this number, even if convergence criteria are not yet satisfied.
)description"
                };
 
                using ValueType = uint32_t;
 
                static constexpr Range<uint32_t> validRange()
                {
                    return { std::numeric_limits<uint32_t>::lowest(), std::numeric_limits<uint32_t>::max() };
                }
 
                MaxIterationCount() = default;
 
                explicit constexpr MaxIterationCount(uint32_t value)
                    : m_value{ value }
                {}
 
                uint32_t value() const;
 
                std::string toString() const;
 
                bool operator==(const MaxIterationCount &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const MaxIterationCount &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const MaxIterationCount &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const MaxIterationCount &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const MaxIterationCount &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const MaxIterationCount &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const MaxIterationCount &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                uint32_t m_value{ 200 };
 
                friend struct DataModel::Detail::Befriend<MaxIterationCount>;
            };
 
            using Descendants = std::tuple<
                LocalPointCloudRegistrationParameters::ConvergenceCriteria,
                LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold,
                LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold,
                LocalPointCloudRegistrationParameters::MaxCorrespondenceDistance,
                LocalPointCloudRegistrationParameters::MaxIterationCount>;
 
            LocalPointCloudRegistrationParameters();
 
            explicit LocalPointCloudRegistrationParameters(const std::string &fileName);
 
            [[nodiscard]] static LocalPointCloudRegistrationParameters fromSerialized(const std::string &value);
 
            std::string serialize() const;
 
#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit LocalPointCloudRegistrationParameters(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to LocalPointCloudRegistrationParameters(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            LocalPointCloudRegistrationParameters copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }
 
            const ConvergenceCriteria &convergenceCriteria() const
            {
                return m_convergenceCriteria;
            }
 
            ConvergenceCriteria &convergenceCriteria()
            {
                return m_convergenceCriteria;
            }
 
            LocalPointCloudRegistrationParameters &set(const ConvergenceCriteria &value)
            {
                m_convergenceCriteria = value;
                return *this;
            }
 
            LocalPointCloudRegistrationParameters &set(const ConvergenceCriteria::RMSEDiffThreshold &value)
            {
                m_convergenceCriteria.set(value);
                return *this;
            }
 
            LocalPointCloudRegistrationParameters &set(const ConvergenceCriteria::SourceCoverageDiffThreshold &value)
            {
                m_convergenceCriteria.set(value);
                return *this;
            }
 
            const MaxCorrespondenceDistance &maxCorrespondenceDistance() const
            {
                return m_maxCorrespondenceDistance;
            }
 
            MaxCorrespondenceDistance &maxCorrespondenceDistance()
            {
                return m_maxCorrespondenceDistance;
            }
 
            LocalPointCloudRegistrationParameters &set(const MaxCorrespondenceDistance &value)
            {
                m_maxCorrespondenceDistance = value;
                return *this;
            }
 
            const MaxIterationCount &maxIterationCount() const
            {
                return m_maxIterationCount;
            }
 
            MaxIterationCount &maxIterationCount()
            {
                return m_maxIterationCount;
            }
 
            LocalPointCloudRegistrationParameters &set(const MaxIterationCount &value)
            {
                m_maxIterationCount = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, LocalPointCloudRegistrationParameters::ConvergenceCriteria>::value,
                    int>::type = 0>
            const LocalPointCloudRegistrationParameters::ConvergenceCriteria &get() const
            {
                return m_convergenceCriteria;
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold>::
                        value,
                    int>::type = 0>
            const LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold &get() const
            {
                return m_convergenceCriteria
                    .get<LocalPointCloudRegistrationParameters::ConvergenceCriteria::RMSEDiffThreshold>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<
                        T,
                        LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold>::value,
                    int>::type = 0>
            const LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold &get() const
            {
                return m_convergenceCriteria
                    .get<LocalPointCloudRegistrationParameters::ConvergenceCriteria::SourceCoverageDiffThreshold>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, LocalPointCloudRegistrationParameters::MaxCorrespondenceDistance>::value,
                    int>::type = 0>
            const LocalPointCloudRegistrationParameters::MaxCorrespondenceDistance &get() const
            {
                return m_maxCorrespondenceDistance;
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, LocalPointCloudRegistrationParameters::MaxIterationCount>::value,
                    int>::type = 0>
            const LocalPointCloudRegistrationParameters::MaxIterationCount &get() const
            {
                return m_maxIterationCount;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const LocalPointCloudRegistrationParameters::ConvergenceCriteria &get() const
            {
                return m_convergenceCriteria;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const LocalPointCloudRegistrationParameters::MaxCorrespondenceDistance &get() const
            {
                return m_maxCorrespondenceDistance;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const LocalPointCloudRegistrationParameters::MaxIterationCount &get() const
            {
                return m_maxIterationCount;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_convergenceCriteria);
                f(m_maxCorrespondenceDistance);
                f(m_maxIterationCount);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_convergenceCriteria);
                f(m_maxCorrespondenceDistance);
                f(m_maxIterationCount);
            }
 
            bool operator==(const LocalPointCloudRegistrationParameters &other) const;
 
            bool operator!=(const LocalPointCloudRegistrationParameters &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const LocalPointCloudRegistrationParameters &value)
            {
                return stream << value.toString();
            }
 
            void save(const std::string &fileName) const;
 
            void load(const std::string &fileName);
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            ConvergenceCriteria m_convergenceCriteria;
            MaxCorrespondenceDistance m_maxCorrespondenceDistance;
            MaxIterationCount m_maxIterationCount;
 
            friend struct DataModel::Detail::Befriend<LocalPointCloudRegistrationParameters>;
        };
 
#ifndef NO_DOC
        template<>
        struct LocalPointCloudRegistrationParameters::Version<1>
        {
            using Type = LocalPointCloudRegistrationParameters;
        };
#endif
 
    } // namespace Experimental
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(
        const Zivid::Experimental::LocalPointCloudRegistrationParameters &dataModel,
        std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(
        Zivid::Experimental::LocalPointCloudRegistrationParameters &dataModel,
        std::istream &istream);
 
    ZIVID_CORE_EXPORT std::vector<uint8_t> serializeToBinaryVector(
        const Zivid::Experimental::LocalPointCloudRegistrationParameters &source);
    ZIVID_CORE_EXPORT void deserializeFromBinaryVector(
        Zivid::Experimental::LocalPointCloudRegistrationParameters &dest,
        const std::vector<uint8_t> &data);
 
} // namespace Zivid::Detail
#endif
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#ifndef NO_DOC
#    if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
namespace std // NOLINT
{
 
    template<>
    struct tuple_size<Zivid::Experimental::LocalPointCloudRegistrationParameters::ConvergenceCriteria>
        : integral_constant<size_t, 2>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Experimental::LocalPointCloudRegistrationParameters::ConvergenceCriteria>
    {
        static_assert(
            i < tuple_size<Zivid::Experimental::LocalPointCloudRegistrationParameters::ConvergenceCriteria>::value,
            "Index must be less than 2");
 
        using type // NOLINT
            = decltype(declval<Zivid::Experimental::LocalPointCloudRegistrationParameters::ConvergenceCriteria>()
                           .get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Experimental::LocalPointCloudRegistrationParameters> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Experimental::LocalPointCloudRegistrationParameters>
    {
        static_assert(
            i < tuple_size<Zivid::Experimental::LocalPointCloudRegistrationParameters>::value,
            "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Experimental::LocalPointCloudRegistrationParameters>().get<i>());
    };
 
} // namespace std
#    endif
#endif
 
// If we have access to the DataModel library, automatically include internal DataModel
// header. This header is necessary for serialization and deserialization.
#if defined(__has_include) && !defined(NO_DOC)
#    if __has_include(                                                                                                 \
        "Zivid/Experimental/LocalPointCloudRegistrationParametersInternal.h")                                          \
        && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/Experimental/LocalPointCloudRegistrationParametersInternal.h"
#    endif
#endif