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_