Camera.h

Go to the documentation of this file.

/*[
 * This file is part of the Zivid 3D Camera API
 *
 * Copyright 2015-2018 (C) Zivid Labs. All rights reserved.
 * Contact info@zividlabs.com or see http://www.zividlabs.com
 * 
 * This code is proprietary and confidential.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
]*/

#pragma once


#include <memory>
#include <functional>
#include "APIExport.h"
#include "Settings.h"
#include "ComputeDevice.h"
#include "DeviceCloud.h"
#include "Frame.h"
#include "SerialNumber.h"
#include "CameraRevision.h"

namespace Zivid
{
    class CloudVisualizer;

    class Camera
    {
    public:
        using FrameCallback = std::function<void(Frame)>;

        using StateCallback = std::function<void(CameraState)>;

    public:
        ZIVID_API Camera();
        ZIVID_API ~Camera();
        ZIVID_API Camera(const Camera &other) noexcept;
        ZIVID_API Camera &operator=(const Camera &other) noexcept;
        ZIVID_API Camera(Camera && other) noexcept;
        ZIVID_API Camera &operator=(Camera && other) noexcept;

        ZIVID_API Camera &connect();

        ZIVID_API Camera &connect(const Settings &settings);

        ZIVID_API void disconnect();

        ZIVID_API void setSettings(Settings settings);

        ZIVID_API Settings settings() const;

        ZIVID_API DeviceCloud allocateDeviceCloud();

        ZIVID_API CameraState state() const;

        ZIVID_API void setComputeDevice(ComputeDevice device);

        ZIVID_API void setFrameCallback(FrameCallback callback);

        ZIVID_API void startLive();

        ZIVID_API void stopLive();

        ZIVID_API Frame capture();

        ZIVID_API Frame capture(DeviceCloud& deviceCloud);

        ZIVID_API ComputeDevice computeDevice();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
        ZIVID_API explicit Camera(class CameraImpl && other);
#endif
        ZIVID_API std::string modelName() const;

        ZIVID_API CameraRevision revision() const;

        ZIVID_API SerialNumber serialNumber() const;

        ZIVID_API std::string firmwareVersion() const;

        ZIVID_API std::string toString() const;

        ZIVID_API bool operator==(const Camera &other) const;
        ZIVID_API bool operator!=(const Camera &other) const;

    private:

        std::shared_ptr<class CameraImpl> m_impl;
    };

    ZIVID_API std::ostream &operator<<(std::ostream &stream, const Camera &camera);

    class SettingsBatch
    {
    public:
        explicit SettingsBatch(Camera &camera)
            : m_settings{ camera.settings() }
            , m_camera{ camera }
        {}

        SettingsBatch(const SettingsBatch &) = delete;
        SettingsBatch &operator =(const SettingsBatch &) = delete;
        SettingsBatch &operator =(SettingsBatch &&) = delete;

        SettingsBatch(SettingsBatch && other) noexcept
            : m_settings{ std::move(other.m_settings) }
            , m_camera{ other.m_camera }
        {
            other.m_apply = false;
        }

        ~SettingsBatch()
        {
            if (m_apply)
            {
                m_camera.setSettings(std::move(m_settings));
            }
        }

        template<typename Setting>
        SettingsBatch &set(Setting value)
        {
            m_settings.set(value.path, value.toString());
            return *this;
        }

        template<typename Setting>
        friend SettingsBatch operator << (SettingsBatch && setter, Setting value)
        {
            setter.set(value);
            return std::move(setter);
        }

    private:
        bool m_apply{ true };
        Settings m_settings;
        Camera &m_camera;
    };

    template<typename Setting>
    SettingsBatch operator << (Camera &camera, Setting value)
    {
        return SettingsBatch{ camera } << value;
    }
} // namespace Zivid