Settings2D.h

Go to the documentation of this file.

 
/*******************************************************************************
 * This file is part of the Zivid 3D Camera API
 *
 * Copyright 2015-2020 (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 Support <support@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <chrono>
#include <ctime>
#include <iomanip>
#include <memory>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/APIExport.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
{
    class ZIVID_API_EXPORT Settings2D
    {
    public:
        static constexpr size_t version{ 1 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::Settings2D;
#endif
 
        ~Settings2D();
 
        Settings2D(const Settings2D &other);
 
        Settings2D &operator=(const Settings2D &other);
 
        Settings2D(Settings2D &&other) noexcept;
 
        Settings2D &operator=(Settings2D &&other) noexcept;
 
        Settings2D() = default;
 
        static constexpr bool isContainer{ true };
 
        static constexpr const char *path{ "" };
 
        static constexpr const char *name{ "Settings2D" };
 
        static constexpr const char *description{ R"description(2D Capture settings)description" };
 
        void set(const std::string &fullPath, const std::string &value);
 
        std::string getString(const std::string &fullPath) const;
 
        class ZIVID_API_EXPORT Brightness
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Brightness" };
 
            static constexpr const char *name{ "Brightness" };
 
            static constexpr const char *description{
                R"description(Brightness controls the light output from the projector.
 
Brightness above 1.0 may be needed when the distance between the camera and the
scene is large, or in case of high levels of ambient lighting. Brightness above 1.0
is only supported on Zivid One Plus.
 
When brightness is above 1.0 the duty cycle of the camera (the percentage of time the
camera can capture frames) will be reduced. The lights in the projector can be lit for
at most 50% of the time during a 10 second period. This limitation is enforced automatically
by the camera. Calling capture2D when the duty cycle limit has been reached will cause
the camera to first wait (sleep) for a duration of time to cool down, before capture will
start.
)description"
            };
 
            Brightness() = default;
 
            explicit constexpr Brightness(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 0, 1.8 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Brightness &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Brightness &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Brightness &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Brightness &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Brightness &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Brightness &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 1 };
        };
 
        class ZIVID_API_EXPORT ExposureTime
        {
        public:
            using ValueType = std::chrono::microseconds;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "ExposureTime" };
 
            static constexpr const char *name{ "ExposureTime" };
 
            static constexpr const char *description{ R"description(Exposure time for the image.)description" };
 
            ExposureTime() = default;
 
            explicit constexpr ExposureTime(ValueType value) noexcept(
                std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { ValueType{ 6500 }, ValueType{ 100000 } };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = ValueType{ std::stoll(value) };
            }
 
            std::string toString() const
            {
                return std::to_string(m_value.count());
            }
 
            bool operator==(const ExposureTime &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const ExposureTime &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const ExposureTime &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const ExposureTime &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const ExposureTime &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, ExposureTime &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 8333 };
        };
 
        class ZIVID_API_EXPORT Gain
        {
        public:
            using ValueType = double;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Gain" };
 
            static constexpr const char *name{ "Gain" };
 
            static constexpr const char *description{ R"description(Analog gain in the camera)description" };
 
            Gain() = default;
 
            explicit constexpr Gain(ValueType value) noexcept(std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 1, 16 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stod(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Gain &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Gain &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Gain &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Gain &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Gain &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Gain &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 2 };
        };
 
        class ZIVID_API_EXPORT Iris
        {
        public:
            using ValueType = size_t;
 
            static constexpr bool isContainer{ false };
 
            static constexpr const char *path{ "Iris" };
 
            static constexpr const char *name{ "Iris" };
 
            static constexpr const char *description{
                R"description(Iris (aperture) setting for the camera)description"
            };
 
            Iris() = default;
 
            explicit constexpr Iris(ValueType value) noexcept(std::is_nothrow_copy_constructible<ValueType>::value)
                : m_value{ value }
            {}
 
            const ValueType &value() const
            {
                return m_value;
            }
 
            Range<ValueType> range() const
            {
                return { 0, 72 };
            }
 
            void setFromString(const std::string &value)
            {
                m_value = std::stoull(value);
            }
 
            std::string toString() const
            {
                return std::to_string(m_value);
            }
 
            bool operator==(const Iris &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Iris &other) const
            {
                return m_value != other.m_value;
            }
 
            bool operator<(const Iris &other) const
            {
                return m_value < other.m_value;
            }
 
            bool operator>(const Iris &other) const
            {
                return m_value > other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Iris &value)
            {
                return stream << value.toString();
            }
 
            friend std::istream &operator>>(std::istream &stream, Iris &value)
            {
                value.setFromString(
                    std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
                return stream;
            }
 
        private:
            ValueType m_value{ 22 };
        };
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Brightness>::value, int>::type = 0>
        const Settings2D::Brightness &get() const
        {
            return m_brightness;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::ExposureTime>::value, int>::type = 0>
        const Settings2D::ExposureTime &get() const
        {
            return m_exposureTime;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Gain>::value, int>::type = 0>
        const Settings2D::Gain &get() const
        {
            return m_gain;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, Settings2D::Iris>::value, int>::type = 0>
        const Settings2D::Iris &get() const
        {
            return m_iris;
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const Settings2D::Brightness &get() const
        {
            return m_brightness;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const Settings2D::ExposureTime &get() const
        {
            return m_exposureTime;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const Settings2D::Gain &get() const
        {
            return m_gain;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const Settings2D::Iris &get() const
        {
            return m_iris;
        }
 
        explicit Settings2D(const Brightness &brightness,
                            const ExposureTime &exposureTime,
                            const Gain &gain,
                            const Iris &iris);
 
    private:
        Brightness m_brightness{};
 
    public:
        Settings2D &set(const Brightness &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Brightness{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_brightness = value;
            return *this;
        }
        const Brightness &brightness() const
        {
            return m_brightness;
        }
 
    private:
        ExposureTime m_exposureTime{};
 
    public:
        Settings2D &set(const ExposureTime &value)
        {
            if(value.value().count() < value.range().min().count()
               || value.value().count() > value.range().max().count())
            {
                throw std::out_of_range("ExposureTime{ " + std::to_string(value.value().count())
                                        + " } is not in range [" + std::to_string(value.range().min().count()) + ", "
                                        + std::to_string(value.range().max().count()) + "]");
            }
 
            m_exposureTime = value;
            return *this;
        }
        const ExposureTime &exposureTime() const
        {
            return m_exposureTime;
        }
 
    private:
        Gain m_gain{};
 
    public:
        Settings2D &set(const Gain &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Gain{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_gain = value;
            return *this;
        }
        const Gain &gain() const
        {
            return m_gain;
        }
 
    private:
        Iris m_iris{};
 
    public:
        Settings2D &set(const Iris &value)
        {
            if(value.value() < value.range().min() || value.value() > value.range().max())
            {
                throw std::out_of_range("Iris{ " + std::to_string(value.value()) + " } is not in range ["
                                        + std::to_string(value.range().min()) + ", "
                                        + std::to_string(value.range().max()) + "]");
            }
 
            m_iris = value;
            return *this;
        }
        const Iris &iris() const
        {
            return m_iris;
        }
 
        template<typename F>
        void forEach(const F &f) const
        {
            f(m_brightness);
            f(m_exposureTime);
            f(m_gain);
            f(m_iris);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_brightness);
            f(m_exposureTime);
            f(m_gain);
            f(m_iris);
        }
 
        template<typename F>
        void traverseValues(const F &f) const
        {
            f(m_brightness);
            f(m_exposureTime);
            f(m_gain);
            f(m_iris);
        }
 
        template<typename F>
        void traverseValues(const F &f)
        {
            f(m_brightness);
            f(m_exposureTime);
            f(m_gain);
            f(m_iris);
        }
 
        std::string toString() const;
 
        friend std::ostream &operator<<(std::ostream &stream, const Settings2D &value)
        {
            return stream << value.toString();
        }
 
        void setFromString(const std::string &value);
 
        friend std::istream &operator>>(std::istream &stream, Settings2D &value)
        {
            value.setFromString(
                std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
            return stream;
        }
 
        bool operator==(const Settings2D &other) const;
 
        bool operator!=(const Settings2D &other) const;
 
        explicit Settings2D(const std::string &fileName);
 
        void save(const std::string &fileName) const;
 
        void load(const std::string &fileName);
    };
 
#ifndef NO_DOC
    template<>
    struct Settings2D::Version<1>
    {
        using Type = Settings2D;
    };
#endif
 
} // namespace Zivid
 
#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::Settings2D> : integral_constant<size_t, 4>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings2D>
    {
        using type // NOLINT
            = decltype(declval<Zivid::Settings2D>().get<i>());
    };
 
} // namespace std
#    endif
#endif