VRS - The Virtual Rendering System

version 3.3

camerapatheditor.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2006 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  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 Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: $
//
// $Log: $

#include <vrs/sg/interactiontechnique.h>
#include <vrs/image/avimaker.h>

#ifndef VRS_SG_CAMERAPATHEDITOR_H
#define VRS_SG_CAMERAPATHEDITOR_H

namespace VRS {

    class Callback;
    class CameraPathRecorder;
//kai
        class KeyFrame;
   

    class VRS_CORE_API CameraPathEditor : public InteractionTechnique {
    public:

        CameraPathEditor(
            SO<CameraPathRecorder> recorder,
            const std::string& cameraPathFileName = "cameraPath.txt",
            const std::string& imageSequenceDirectory = "video/",
            unsigned int imageSequenceWidth = 768,
            unsigned int imageSequenceHeight = 576,
            unsigned int imageSequenceFramesPerSecond = 25
        );

        static const Vector UpVector;

        static const KeyFunctionID AppendKeyFrame;                  // default: Shift + Alt + Ctrl 'A'
        static const KeyFunctionID AppendKeyFrameAbsolute;          // default: Shift + Alt + Ctrl 'Q'
        static const KeyFunctionID AppendKeyFrameAtEnd;             // default: Shift + Alt + Ctrl 'N'
        static const KeyFunctionID NextKeyFrame;                    // default: Shift + Alt + Ctrl ->
        static const KeyFunctionID PrevKeyFrame;                    // default: Shift + Alt + Ctrl <-
        static const KeyFunctionID ClearAll;                        // default: Shift + Alt + Ctrl 'X'
        static const KeyFunctionID CursorToStartKeyFrame;           // default: Shift + Alt + Ctrl PageUp
        static const KeyFunctionID CursorToEndStartKeyFrame;        // default: Shift + Alt + Ctrl PageDown        
        static const KeyFunctionID GotoKeyFrame;                    // default: Shift + Alt + Ctrl 'G'
        static const KeyFunctionID OverwriteKeyFrame;               // default: Shift + Alt + Ctrl 'O'
        static const KeyFunctionID OverwriteKeyFrameAbsolute;       // default: Shift + Alt + Ctrl 'I'
        static const KeyFunctionID DeleteKeyFrame;                  // default: Shift + Alt + Ctrl 'D'
        static const KeyFunctionID RenameKeyFrame;                  // default: Shift + Alt + Ctrl 'R'
        static const KeyFunctionID LoadKeyFrames;                   // default: Shift + Alt + Ctrl '9'
        static const KeyFunctionID SaveKeyFrames;                   // default: Shift + Alt + Ctrl '0'
        static const KeyFunctionID MarkAsCircleKeyFrame;            // default: Shift + Alt + Ctrl 'C'        
        static const KeyFunctionID PlayFromCursor;                  // default: Shift + Alt + Ctrl 'P'
        static const KeyFunctionID StopPlaying;                     // default: Shift + Alt + Ctrl 'S'
        static const KeyFunctionID SetPathTime;                     // default: Shift + Alt + Ctrl 'T'
        static const KeyFunctionID SetDefaultSpeed;                 // default: Shift + Alt + Ctrl '1'
        static const KeyFunctionID SetSpeedMark;                    // default: Shift + Alt + Ctrl 'M'        
        static const KeyFunctionID ExportCameraPathRecorderFile;    // default: Shift + Alt + Ctrl 'E'
        static const KeyFunctionID ExportImageSequence;             // default: Shift + Alt + Ctrl 'V'        
        static const KeyFunctionID PrintKeyAssignments;             // default: Shift + Alt + Ctrl 'H'
        static const KeyFunctionID PrintLookAt;                     // default: Shift + Alt + Ctrl 'L'

        
        void appendKeyFrame(const Vector& from, const Vector& dirOrTo, bool isLookTo = false);

        int keyFrames() const;

        int keyFrameCursor() const;
        void setKeyFrameCursor(int pos);
        
        void gotoKeyFrame();

        void overwriteKeyFrame(const Vector& from, const Vector& dirOrTo, bool isLookTo = false);
        
        void deleteKeyFrame();
        void clear();

        void renameKeyFrame(const std::string& name);
        
        std::string getKeyFrameName();

        void setKeyFrameFile(const std::string& name);
        std::string getKeyFrameFile() const;               
        void loadKeyFrames();
        void saveKeyFrames() const;

        void setImageSequenceDirectory(const std::string& name);
        std::string getImageSequenceDirectory() const;               
        void setImageSequenceSize(unsigned int width, unsigned int height);
        unsigned int getImageSequenceWidth() const;               
        unsigned int getImageSequenceHeight() const;               
        void setImageSequenceFramerate(unsigned int fps);
        unsigned int getImageSequenceFramerate() const;               
       
        void markAsCircleKeyFrame(const Vector& target, int minimumRotations = 0);
        void unmarkCircleKeyFrame();
        
        void playFromCursor();

        void stopPlaying();

        bool isActive();

        void setDefaultSpeed(double speed);
        double getDefaultSpeed() const;

        void setSpeedMark(double speedFactor, bool startSpeedChange, double relativeAcceleration);
        void removeSpeedMark();
                
        virtual void onKey(SO<VRS::KeyEvent> event, KeyFunctionID id);

        void printKeyAssignments() const;

        virtual void onTimer(SO<TimeEvent> event, double secondsSinceLastTimeEvent);
                //kai
                //SO<KeyAssignment> findKeyFunctionID(SO<KeyEvent> event, KeyFunctionID& id) const; 
        
                virtual void onEventPassive(SO<Event> e, bool modeActive);

        void createCameraPath() const;

        double getPathLength() const;

        double getPathDuration() const;

        void recordCameraPath();

        void recordVideo(const std::string& filename, unsigned int sizeX, unsigned int sizeY, int framesPerSecond, bool highQuality = false, VRS::VideoCompressor* compressor = NULL);
                

                void recordVideo(const std::string& targetFilename, const std::string& targetDirectory, const std::string& targetFormat, 
                        unsigned int sizeX, unsigned int sizeY, int framesPerSecond, VRS::VideoCompressor* compressor = NULL);
                
        void setPathDuration(double targetTime);
                
        int getCircleTurns(unsigned int index);
        
        // one camera view point
        struct VRS_CORE_API CameraPoint {
            Vector lookFrom;
            Vector lookTo;
            Vector lookUp;

            double summedDistance;
            bool isKeyframe;
            VRS_SERIALIZABLE_NO_SO_CLASS(CameraPoint);
        };
                
                // main KeyFrame datastructure for use outside the editor
                struct VRS_CORE_API KeyFrame {
                        KeyFrame(const Vector& from, const Vector& dir);
                        KeyFrame();
                        Vector m_from;
                        Vector m_dir;
                        bool m_isSpeedMark;
                        double m_relativeSpeed;
                        bool m_startSpeedChange;
                        double m_relativeAcceleration;
                        bool m_isCircleEntry;
                        Vector m_circleMidpoint;
                        int m_circlePasses;
                        std::string m_name;
                        bool m_dirIsLookTo;
                        VRS_SERIALIZABLE_NO_SO_CLASS(KeyFrame);
                };

                SO<Array<KeyFrame>> keyFramesList(){return m_keyFrames;}

                KeyFrame* keyFrame(unsigned int id);
                
                void pathNotValid(){m_pathValid = false; }

                CameraPoint getKeyFrame(unsigned int id);

        virtual void registerPathStoppedCallback(VRS::SO<VRS::Callback> callback);
        virtual void unregisterPathStoppedCallback(VRS::SO<VRS::Callback> callback);

        VRS_TYPEINFO(CameraPathEditor, InteractionTechnique);        
        VRS_SERIALIZABLE(CameraPathEditor);
    private:
        
        CameraPathEditor();
       


        SO<Array<KeyFrame> > m_keyFrames;
        int m_currentKeyFrame;
        SO<CameraPathRecorder> m_recorder;
        std::string m_keyFrameFile;
        std::string m_imageSequenceDirectory;
        unsigned int m_imageSequenceWidth;
        unsigned int m_imageSequenceHeight;
        unsigned int m_imageSequenceFramerate;
        double m_defaultSpeed;



        bool m_playing;
        double m_elapsedTime;
        double startTime_;
        unsigned int renderedFrames_;
        std::string m_cameraPathFile;

        // computed in createCameraPath()
        mutable SO<Iterator<double> > m_keyFrame2Time; 
        mutable double m_pathLength; 
        mutable bool m_pathValid;
        
        void printKey(KeyFunctionID id, const std::string& text) const;

        SO<Iterator<double> > computeTimeStamps(SO<Iterator<CameraPoint> > cpoints);

        VRS::SO<VRS::Array<VRS::SO<VRS::Callback> > > m_pathStoppedCallbacks;
                };

        


}

#endif // VRS_SG_CAMERAPATHEDITOR_H

---

Generated on Fri May 18 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact