key_frame_interpolator.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/

 
#ifndef EASY3D_RENDERER_KEY_FRAME_INTERPOLATOR_H
#define EASY3D_RENDERER_KEY_FRAME_INTERPOLATOR_H
 
#include <easy3d/core/types.h>
#include "easy3d/util/signal.h"
#include <easy3d/util/timer.h>
#include <easy3d/renderer/frame.h>
 
#include <vector>
 
 
namespace easy3d {
 
    class Frame;
    class Camera;
    class LinesDrawable;
    class TrianglesDrawable;

    class KeyFrameInterpolator
    {
    public:
        explicit KeyFrameInterpolator(Frame *frame = nullptr);

        virtual ~KeyFrameInterpolator();

    public:
        bool add_keyframe(const Frame& frame);

        bool add_keyframe(const Frame& frame, float time);

        void delete_last_keyframe();

        void set_keyframe_time(std::size_t index, float t);

        void set_keyframe_position(std::size_t index, const vec3& pos);

        void set_keyframe_orientation(std::size_t index, const quat& q);

        void delete_path();

    public:
        Frame* frame() const { return frame_; }
 
    public:
        void set_frame(Frame* const frame) { frame_ = frame; }

    public:
        std::size_t number_of_keyframes() const { return keyframes_.size(); }

        Frame keyframe(std::size_t index) const;

        float keyframe_time(std::size_t index) const;

        const vec3& keyframe_position(std::size_t index) const;

        const quat& keyframe_orientation(std::size_t index) const;

        float duration() const;

        float first_time() const;

        float last_time() const;

    public:

        enum Method {
            FITTING,        
            INTERPOLATION   
        };

        Method interpolation_method() const { return interpolation_method_; }

        float interpolation_speed() const { return interpolation_speed_; }

        int interpolation_period() const { return static_cast<int>(1000.0 / fps_); }

        int frame_rate() const { return fps_; }
 
    public:
        void set_interpolation_method(Method m);

        void set_interpolation_speed(float speed);

        void set_frame_rate(int fps);

    public:
        bool is_interpolation_started() const { return interpolation_started_; }
 
    public:
        void start_interpolation();

        void stop_interpolation();

        void toggle_interpolation() {
            if (is_interpolation_started())
                stop_interpolation();
            else
                start_interpolation();
        }
 
    public:
        const std::vector<Frame>& interpolate();

    public:

        void draw_cameras(const Camera* camera, float camera_width, const vec4& color = vec4(0.5f, 0.8f, 0.5f, 1.0f));

        void draw_path(const Camera* camera, float thickness = 2.0f, const vec4& color = vec4(1.0f, 1.0f, 0.5f, 1.0f));


    public:
        bool save_keyframes(const std::string& file_name) const;
        bool read_keyframes(const std::string& file_name);
 
    private:
        // Copy constructor and operator= are declared private and undefined
        // Prevents everyone from trying to use them
        KeyFrameInterpolator(const KeyFrameInterpolator& kfi);
        KeyFrameInterpolator& operator=(const KeyFrameInterpolator& kfi);
 
        // Internal private Keyframe representation
        class Keyframe
        {
        public:
            Keyframe(const Frame& fr, float t);
            const vec3& position() const { return p_; }
            const quat& orientation() const { return q_; }
            float time() const { return time_; }
            void set_time(float t) { time_ = t; }
            void set_position(const vec3& p) { p_ = p; }
            void set_orientation(const quat& q) { q_ = q; }
            void flip_if_needed(const quat& prev); // flip its orientation if needed
        private:
            vec3 p_;
            quat q_;
            float time_;
        };
 
    private:
        // Associated frame
        Frame* frame_;
 
        // Key Frames
        std::vector<Keyframe> keyframes_;
        std::vector<Frame> interpolated_path_;
 
        // Rhythm
        Timer<> timer_;
        int fps_;
        Method interpolation_method_;
        float interpolation_speed_;
        bool interpolation_started_;
        int last_stopped_index_;
 
        // is path valid? Adding new keyframes or editing a keyframe invalidates the path
        bool pathIsValid_;
 
        LinesDrawable* path_drawable_;
        TrianglesDrawable* cameras_drawable_;
 
    public:
        Signal<> frame_interpolated;    
        Signal<> interpolation_stopped; 
    };
 
}
 
 
#endif // EASY3D_RENDERER_KEY_FRAME_INTERPOLATOR_H