Visualizer.h

Go to the documentation of this file.

#ifndef SimTK_SIMBODY_VISUALIZER_H_
#define SimTK_SIMBODY_VISUALIZER_H_
 
/* -------------------------------------------------------------------------- *
 *                               Simbody(tm)                                  *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2010-14 Stanford University and the Authors.        *
 * Authors: Peter Eastman, Michael Sherman                                    *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */
 
#include "simbody/internal/common.h"
 
#include <utility> // for std::pair
 
namespace SimTK {
 
class MobilizedBody;
class MultibodySystem;
class DecorationGenerator;
 
class SimTK_SIMBODY_EXPORT Visualizer {
public:
class FrameController; // defined below
class BodyFollower;    // declared below, defined in Visualizer.cpp
class InputListener;   // defined in Visualizer_InputListener.h
class InputSilo;       //                 "
class Reporter;        // defined in Visualizer_Reporter.h
 
 
explicit Visualizer(const MultibodySystem& system);
 
Visualizer(const MultibodySystem& system,
           const Array_<String>&  searchPath);
 
Visualizer(const Visualizer& src);
Visualizer& operator=(const Visualizer& src);
~Visualizer();
 
void shutdown();
 
Visualizer& setShutdownWhenDestructed(bool shouldShutdown);
 
bool getShutdownWhenDestructed() const;
 
enum Mode {
    PassThrough = 1,
    Sampling    = 2,
    RealTime    = 3
};
 
enum BackgroundType {
    GroundAndSky = 1,
    SolidColor   = 2
};
 
enum PredefinedMenuIds {
    ViewMenuId    = -1
};
 
Visualizer& setBackgroundType(BackgroundType background);
 
 
const Visualizer& setBackgroundColor(const Vec3& color) const;
 
const Visualizer& setShowShadows(bool showShadows) const;
 
const Visualizer& setShowFrameRate(bool showFrameRate) const;
 
const Visualizer& setShowSimTime(bool showSimTime) const;
 
const Visualizer& setShowFrameNumber(bool showFrameNumber) const;
 
const Visualizer& setWindowTitle(const String& title) const;
Visualizer& setSystemUpDirection(const CoordinateDirection& upDirection);
CoordinateDirection getSystemUpDirection() const;
 
Visualizer& setGroundHeight(Real height);
Real getGroundHeight() const;
 
 
Visualizer& setMode(Mode mode);
Mode getMode() const;
 
Visualizer& setDesiredFrameRate(Real framesPerSec);
Real getDesiredFrameRate() const;
 
Visualizer& setRealTimeScale(Real simTimePerRealSecond);
Real getRealTimeScale() const;
 
Visualizer& setDesiredBufferLengthInSec(Real bufferLengthInSec);
Real getDesiredBufferLengthInSec() const;
Real getActualBufferLengthInSec() const;
int getActualBufferLengthInFrames() const;
 
int addInputListener(InputListener* listener);
int getNumInputListeners() const;
const InputListener& getInputListener(int i) const;
InputListener& updInputListener(int i);
 
int addFrameController(FrameController* controller);
int getNumFrameControllers() const;
const FrameController& getFrameController(int i) const;
FrameController& updFrameController(int i);
 
void report(const State& state) const;
 
void flushFrames() const;
 
void drawFrameNow(const State& state) const;
Visualizer& addMenu(const String& title, int id, 
                   const Array_<std::pair<String, int> >& items);
 
Visualizer& addSlider(const String& title, int id, Real min, Real max, Real value);
 
int addDecoration(MobilizedBodyIndex mobodIx, const Transform& X_BD, 
                  const DecorativeGeometry& geometry);
int getNumDecorations() const;
const DecorativeGeometry& getDecoration(int i) const;
DecorativeGeometry& updDecoration(int i) const;
 
int addRubberBandLine(MobilizedBodyIndex b1, const Vec3& station1,
                      MobilizedBodyIndex b2, const Vec3& station2,
                      const DecorativeLine& line);
int getNumRubberBandLines() const;
const DecorativeLine& getRubberBandLine(int i) const;
DecorativeLine& updRubberBandLine(int i) const;
 
int addDecorationGenerator(DecorationGenerator* generator);
int getNumDecorationGenerators() const;
const DecorationGenerator& getDecorationGenerator(int i) const;
DecorationGenerator& updDecorationGenerator(int i);
const Visualizer& setCameraTransform(const Transform& X_GC) const;
 
const Visualizer& zoomCameraToShowAllGeometry() const;
 
const Visualizer& pointCameraAt(const Vec3& point, const Vec3& upDirection) const;
 
const Visualizer& setCameraFieldOfView(Real fov) const;
 
const Visualizer& setCameraClippingPlanes(Real nearPlane, Real farPlane) const;
 
const Visualizer& setSliderValue(int slider, Real value) const;
 
const Visualizer& setSliderRange(int slider, Real newMin, Real newMax) const;
 
 
void dumpStats(std::ostream& o) const;
void clearStats();
const Array_<InputListener*>&   getInputListeners() const;
const Array_<FrameController*>& getFrameControllers() const;
const MultibodySystem&          getSystem() const;
int getRefCount() const;
class Impl;
//--------------------------------------------------------------------------
                                private:
explicit Visualizer(Impl* impl);
Impl* impl;
 
const Impl& getImpl() const {assert(impl); return *impl;}
Impl&       updImpl()       {assert(impl); return *impl;}
friend class Impl;
};
 
class SimTK_SIMBODY_EXPORT Visualizer::FrameController {
public:
    virtual void generateControls(const Visualizer&           viz, 
                                  const State&                state,
                                  Array_<DecorativeGeometry>& geometry) = 0;
 
    virtual ~FrameController() {}
};
 
// This class is based on the BodyWatcher class that used to be in TimsBox.cpp.
class SimTK_SIMBODY_EXPORT Visualizer::BodyFollower :
    public Visualizer::FrameController {
public:
    BodyFollower(const MobilizedBody& mobodB,
                 const Vec3&          stationPinB = Vec3(0, 0, 0),
                 const Vec3&          offset      = Vec3(NaN),
                 const UnitVec3&      upDirection = UnitVec3());
 
    void generateControls(
            const Visualizer&             viz,
            const State&                  state,
            Array_< DecorativeGeometry >& geometry) override;
 
private:
    const MobilizedBody& m_mobodB;
    const Vec3&          m_stationPinB;
    const Vec3&          m_offset;
    const UnitVec3&      m_upDirection;
};
 
typedef Visualizer VTKVisualizer;
 
} // namespace SimTK
 
#endif // SimTK_SIMBODY_VISUALIZER_H_