turntable_camera.h

Go to the documentation of this file.

/* $Id: turntable_camera.h 18278 2014-11-25 01:42:10Z ksimek $ */
/* =========================================================================== *
   |
   |  Copyright (c) 1994-2010 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek
 * =========================================================================== */

#ifndef KJB_ST_TURNTABLE_CAMERA_H
#define KJB_ST_TURNTABLE_CAMERA_H

#include <vector>
#include <string>
#include <m_cpp/m_vector.h>
#include <camera_cpp/perspective_camera.h>


#ifdef KJB_HAVE_BST_SERIAL
#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>
#endif

namespace kjb
{
    class Calibrated_camera;
class Turntable_camera
{
#ifdef KJB_HAVE_BST_SERIAL
    friend class boost::serialization::access;
#endif

public:
    Turntable_camera();

    Turntable_camera(
        const Perspective_camera& cam,
        const Vector& rotation_axis,
        const Vector& turntable_origin,
        int num_positions,
        bool clockwise = true);

    template <typename Iterator>
    Turntable_camera(
        const Perspective_camera& cam,
        const Vector& rotation_axis,
        const Vector& turntable_origin,
        Iterator angles_begin,
        Iterator angles_end) :
            neutral_camera_(cam),
            turntable_origin_(turntable_origin),
            rotation_axis_(rotation_axis),
            angles_(angles_begin, angles_end),
            true_angles_(angles_),
            current_index_(0),
            current_camera_(neutral_camera_),
            indices_()
    {

        indices_.resize(angles_.size());
        for(size_t i = 0; i < angles_.size(); ++i)
            indices_[i] = i;
    }

    Turntable_camera(const Turntable_camera& other);

    Turntable_camera& operator=(const Turntable_camera& other)
    {
        Turntable_camera result(other);
        swap(result);
        return *this;
    }

    virtual void swap(Turntable_camera& other);

    const Vector& get_principal_point() const
    {
        assert(angles_.size() > 0);
        return neutral_camera_.get_principal_point();
    }

    void set_principal_point(const Vector& pt)
    {
        assert(angles_.size() > 0);
        neutral_camera_.set_principal_point(pt);
    }

    void set_active_camera(size_t i) const;

    void set_next();

    void set_previous();

    void pass_to_opengl(bool clean_buffers = false) const
    {
        // ensure this has been initialized (not constructed with Default ctor)
        assert(angles_.size() > 0);
        current_camera_.prepare_for_rendering(clean_buffers);
    }

    const Perspective_camera& get_neutral_camera() const
    {
        assert(angles_.size() > 0);
        return neutral_camera_;
    }


    const Vector& get_origin() const
    {
        return turntable_origin_;
    }

    const Vector& get_rotation_axis() const
    {
        return rotation_axis_;
    }

    const std::vector<double>& get_angles() const
    {
        return angles_;
    }

    size_t get_current_index() const
    {
        return current_index_;
    }

    const Perspective_camera& get_current_camera() const
    {
        return current_camera_;
    }

    size_t size() const
    {
        return angles_.size();
    }

    const std::vector<size_t>& index_list()
    {
        return indices_;
    }

    void set_index_list(const Index_range& indices);

    void evenly_space_cameras(size_t n);

    virtual const Perspective_camera operator[](int i) const;

    std::vector<Perspective_camera> to_cameras() const;


private: 
    Perspective_camera neutral_camera_;
    Vector turntable_origin_;
    Vector rotation_axis_;
    std::vector<double> angles_;
    std::vector<double> true_angles_;

    mutable size_t current_index_;
    mutable Perspective_camera current_camera_;

    std::vector<size_t> indices_;

private:

    template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
#ifdef KJB_HAVE_BST_SERIAL
        if(version == 0)
        {
            // no saving to old formats!
            assert(Archive::is_loading::value);

            using namespace boost;
            ar & neutral_camera_;
            ar & turntable_origin_;
            ar & rotation_axis_;
            ar & angles_;

            ar & current_index_;
            ar & current_camera_;

            // fill-in fields added since version 1
            true_angles_ = angles_;
            indices_.resize(angles_.size());
            for(size_t i =0; i < angles_.size(); ++i)
            {
                indices_[i] = i;
            }
        }
        else
        {
            // version 1
            using namespace boost;
            ar & neutral_camera_;
            ar & turntable_origin_;
            ar & rotation_axis_;
            ar & angles_;
            ar & true_angles_;

            ar & current_index_;
            ar & current_camera_;
            ar & indices_;
        }
#else
        KJB_THROW_2(Missing_dependency, "boost::serialization");
#endif
    }
};

Turntable_camera regularize_turntable_cameras(const std::vector<Calibrated_camera>& cameras);


} // namespace kjb

#ifdef KJB_HAVE_BST_SERIAL
// set serializaztion version
namespace boost {
namespace serialization {
    template <>
    struct version<kjb::Turntable_camera >
    {
        typedef mpl::int_<1> type;
        typedef mpl::integral_c_tag tag;
        BOOST_STATIC_CONSTANT(int, value = version::type::value);
    };
}
}
#endif

#endif