DecorativeGeometry.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_DECORATIVE_GEOMETRY_H_
#define SimTK_SimTKCOMMON_DECORATIVE_GEOMETRY_H_
 
/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * 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) 2005-15 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors: Jack Middleton, Peter Eastman, Ayman Habib                   *
 *                                                                            *
 * 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 "SimTKcommon/Simmatrix.h"
#include "SimTKcommon/internal/PolygonalMesh.h"
 
#include <cassert>
 
 
namespace SimTK {
 
// Some common RGB values;
 
constexpr Vec3 Black   = Vec3( 0, 0, 0);
constexpr Vec3 Gray    = Vec3(.5,.5,.5);
constexpr Vec3 Red     = Vec3( 1, 0, 0);
constexpr Vec3 Green   = Vec3( 0, 1, 0);
constexpr Vec3 Blue    = Vec3( 0, 0, 1);
constexpr Vec3 Yellow  = Vec3( 1, 1, 0);
constexpr Vec3 Orange  = Vec3( 1,.5, 0);
constexpr Vec3 Magenta = Vec3( 1, 0, 1);
constexpr Vec3 Purple  = Vec3(.5, 0,.5);
constexpr Vec3 Cyan    = Vec3( 0, 1, 1);
constexpr Vec3 White   = Vec3( 1, 1, 1);
 
// Drawing representations
 
class DecorativeGeometryImplementation;
 
class SimTK_SimTKCOMMON_EXPORT DecorativeGeometry {
public:
DecorativeGeometry() : rep(0) { }
~DecorativeGeometry();
DecorativeGeometry(const DecorativeGeometry& source);
DecorativeGeometry& operator=(const DecorativeGeometry& source);
 
enum Representation {
    Hide = 0, 
    DrawPoints = 1, 
    DrawWireframe =  2, 
    DrawSurface   =  3, 
 
    DrawDefault   = -1  
};
 
DecorativeGeometry& setBodyId(int bodyId);
 
DecorativeGeometry& setIndexOnBody(int index);
 
DecorativeGeometry& setUserRef(void* userRef);
 
DecorativeGeometry& setTransform(const Transform& X_BG);
 
DecorativeGeometry& setResolution(Real);
 
DecorativeGeometry& setScaleFactors(const Vec3& scale);
 
DecorativeGeometry& setScale(Real scale) {return setScaleFactors(Vec3(scale));}
 
int getBodyId() const;
 
int getIndexOnBody() const;
 
void* getUserRef() const; 
 
Real getResolution() const;
 
const Transform& getTransform() const;
 
const Vec3& getScaleFactors() const;
 
DecorativeGeometry& setColor(const Vec3& rgb); // 0-1 for each color
 
DecorativeGeometry& setOpacity(Real);          // 0-1; default is 1 (opaque)
 
DecorativeGeometry& setLineThickness(Real);
 
const Vec3& getColor()      const;
Real getOpacity()    const;
Real getLineThickness() const;
    
DecorativeGeometry& setFaceCamera(int shouldFace);
int getFaceCamera() const;
 
DecorativeGeometry& setRepresentation(const Representation&);
 
Representation getRepresentation() const;
 
void implementGeometry(DecorativeGeometryImplementation&) const;
 
// Bookkeeping below here -- internal use only. Don't look below or you will
// turn into a pillar of salt.
bool isOwnerHandle() const;
bool isEmptyHandle() const;
explicit DecorativeGeometry(class DecorativeGeometryRep* r) : rep(r) { }
bool hasRep() const {return rep!=0;}
const DecorativeGeometryRep& getRep() const {assert(rep); return *rep;}
DecorativeGeometryRep&       updRep()       {assert(rep); return *rep;}
protected:
DecorativeGeometryRep* rep;
};
 
 
class SimTK_SimTKCOMMON_EXPORT DecorativePoint : public DecorativeGeometry {
public:
    explicit DecorativePoint(const Vec3& p=Vec3(0));
 
    // These are specific to DecorativePoint.
 
    DecorativePoint& setPoint(const Vec3& p);
    const Vec3& getPoint() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativePoint& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativePoint& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativePoint& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativePoint& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativePoint& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativePoint& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativePoint& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativePoint& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativePoint& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativePoint& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativePoint, DecorativeGeometry);
private:
    class DecorativePointRep& updRep();
    const DecorativePointRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeLine : public DecorativeGeometry {
public:
    explicit DecorativeLine(const Vec3& p1=Vec3(0), const Vec3& p2=Vec3(1)); // line between p1 and p2
 
    // These are specific to lines.
    DecorativeLine& setPoint1(const Vec3& p1);
    DecorativeLine& setPoint2(const Vec3& p2);
    DecorativeLine& setEndpoints(const Vec3& p1, const Vec3& p2);
 
    // Retain the derived type when setting generic geometry options.
    DecorativeLine& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeLine& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeLine& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeLine& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeLine& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeLine& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeLine& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeLine& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeLine& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeLine& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    const Vec3& getPoint1() const;
    const Vec3& getPoint2() const;
 
    SimTK_PIMPL_DOWNCAST(DecorativeLine, DecorativeGeometry);
private:
    class DecorativeLineRep& updRep();
    const DecorativeLineRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeCircle : public DecorativeGeometry {
public:
    explicit DecorativeCircle(Real radius=0.5);
 
    DecorativeCircle& setRadius(Real);
    Real getRadius() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeCircle& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeCircle& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeCircle& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeCircle& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeCircle& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeCircle& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeCircle& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeCircle& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeCircle& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeCircle& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeCircle, DecorativeGeometry);
private:
    class DecorativeCircleRep& updRep();
    const DecorativeCircleRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeSphere : public DecorativeGeometry {
public:
    explicit DecorativeSphere(Real radius=0.5);
 
    DecorativeSphere& setRadius(Real);
    Real getRadius() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeSphere& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeSphere& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeSphere& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeSphere& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeSphere& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeSphere& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeSphere& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeSphere& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeSphere& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeSphere& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeSphere, DecorativeGeometry);
private:
    class DecorativeSphereRep& updRep();
    const DecorativeSphereRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeEllipsoid : public DecorativeGeometry {
public:
    explicit DecorativeEllipsoid(const Vec3& radii = 
        Vec3(Real(0.5),Real(1/3.),Real(0.25)));
 
    DecorativeEllipsoid& setRadii(const Vec3&);
    const Vec3& getRadii() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeEllipsoid& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeEllipsoid& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeEllipsoid& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeEllipsoid& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeEllipsoid& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeEllipsoid& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeEllipsoid& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeEllipsoid& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeEllipsoid& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeEllipsoid& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeEllipsoid, DecorativeGeometry);
private:
    class DecorativeEllipsoidRep& updRep();
    const DecorativeEllipsoidRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeBrick : public DecorativeGeometry {
public:
    explicit DecorativeBrick(const Vec3& halfLengths = Vec3(Real(0.5)));
 
    DecorativeBrick& setHalfLengths(const Vec3&);
    const Vec3& getHalfLengths() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeBrick& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeBrick& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeBrick& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeBrick& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeBrick& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeBrick& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeBrick& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeBrick& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeBrick& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeBrick& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeBrick, DecorativeGeometry);
private:
    class DecorativeBrickRep& updRep();
    const DecorativeBrickRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeCylinder : public DecorativeGeometry {
public:
    explicit DecorativeCylinder(Real radius=0.5, Real halfHeight=0.5);
 
    DecorativeCylinder& setRadius(Real);
    DecorativeCylinder& setHalfHeight(Real);
    Real getRadius() const;
    Real getHalfHeight() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeCylinder& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeCylinder& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeCylinder& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeCylinder& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeCylinder& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeCylinder& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeCylinder& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeCylinder& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeCylinder& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeCylinder& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeCylinder, DecorativeGeometry);
private:
    class DecorativeCylinderRep& updRep();
    const DecorativeCylinderRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeFrame : public DecorativeGeometry {
public:
    explicit DecorativeFrame(Real axisLength=1);
 
    DecorativeFrame& setAxisLength(Real);
    Real getAxisLength() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeFrame& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeFrame& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeFrame& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeFrame& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeFrame& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeFrame& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeFrame& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeFrame& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeFrame& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeFrame& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeFrame, DecorativeGeometry);
private:
    class DecorativeFrameRep& updRep();
    const DecorativeFrameRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeText : public DecorativeGeometry {
public:
    explicit DecorativeText(const std::string& label="");
 
    DecorativeText& setText(const std::string& label);
    const std::string& getText() const;
 
    DecorativeText& setIsScreenText(bool isScreen);
    bool getIsScreenText() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeText& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeText& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeText& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeText& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeText& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeText& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeText& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeText& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeText& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeText& setFaceCamera(int yn)     {DecorativeGeometry::setFaceCamera(yn);   return *this;}
    DecorativeText& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeText, DecorativeGeometry);
private:
    class DecorativeTextRep& updRep();
    const DecorativeTextRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeMesh : public DecorativeGeometry {
public:
    explicit DecorativeMesh(const PolygonalMesh& mesh);
    const PolygonalMesh& getMesh() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeMesh& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeMesh& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeMesh& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeMesh& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeMesh& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeMesh& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeMesh& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeMesh& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeMesh& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeMesh& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeMesh, DecorativeGeometry);
private:
    class DecorativeMeshRep& updRep();
    const DecorativeMeshRep& getRep() const;
};
 
 
class SimTK_SimTKCOMMON_EXPORT DecorativeMeshFile : public DecorativeGeometry {
public:
    explicit DecorativeMeshFile(const std::string& meshFileName);
    const std::string& getMeshFile() const;
    const PolygonalMesh& getMesh() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeMeshFile& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    DecorativeMeshFile& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    DecorativeMeshFile& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    DecorativeMeshFile& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    DecorativeMeshFile& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    DecorativeMeshFile& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    DecorativeMeshFile& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    DecorativeMeshFile& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    DecorativeMeshFile& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    DecorativeMeshFile& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
    SimTK_PIMPL_DOWNCAST(DecorativeMeshFile, DecorativeGeometry);
private:
    class DecorativeMeshFileRep& updRep();
    const DecorativeMeshFileRep& getRep() const;
};
 
 
class SimTK_SimTKCOMMON_EXPORT DecorativeTorus : public DecorativeGeometry {
public:
    explicit DecorativeTorus(Real torusR=1, Real tubeR=0.1);
 
    DecorativeTorus& setTorusRadius(Real);
    DecorativeTorus& setTubeRadius(Real);
    Real getTorusRadius() const;
    Real getTubeRadius() const;
 
    // Retain the derived type when setting generic geometry options.
    DecorativeTorus& setBodyId(int b)          { DecorativeGeometry::setBodyId(b);        return *this; }
    DecorativeTorus& setIndexOnBody(int x)     { DecorativeGeometry::setIndexOnBody(x);   return *this; }
    DecorativeTorus& setUserRef(void* p)       { DecorativeGeometry::setUserRef(p);       return *this; }
    DecorativeTorus& setTransform(const Transform& X_BD) { DecorativeGeometry::setTransform(X_BD); return *this; }
    DecorativeTorus& setResolution(Real r)     { DecorativeGeometry::setResolution(r);    return *this; }
    DecorativeTorus& setScaleFactors(const Vec3& s) { DecorativeGeometry::setScaleFactors(s); return *this; }
    DecorativeTorus& setColor(const Vec3& rgb) { DecorativeGeometry::setColor(rgb);       return *this; }
    DecorativeTorus& setOpacity(Real o)        { DecorativeGeometry::setOpacity(o);       return *this; }
    DecorativeTorus& setLineThickness(Real t)  { DecorativeGeometry::setLineThickness(t); return *this; }
    DecorativeTorus& setRepresentation(const Representation& r)
    {
        DecorativeGeometry::setRepresentation(r); return *this;
    }
 
    SimTK_PIMPL_DOWNCAST(DecorativeTorus, DecorativeGeometry);
private:
    class DecorativeTorusRep& updRep();
    const DecorativeTorusRep& getRep() const;
};
 
 
class SimTK_SimTKCOMMON_EXPORT DecorativeArrow : public DecorativeGeometry {
public:
    explicit DecorativeArrow(const Vec3& startPoint = Vec3(0), const Vec3& endPoint = Vec3(1), Real tipLength = 0.35); // Arrow 
    const Vec3& getStartPoint() const;
    const Vec3& getEndPoint() const;
    const Real& getTipLength() const;
 
    DecorativeArrow& setStartPoint(const Vec3& start);
    DecorativeArrow& setEndPoint(const Vec3& end);
    DecorativeArrow& setTipLength(Real);
 
    // Retain the derived type when setting generic geometry options.
    DecorativeArrow& setBodyId(int b)          { DecorativeGeometry::setBodyId(b);        return *this; }
    DecorativeArrow& setIndexOnBody(int x)     { DecorativeGeometry::setIndexOnBody(x);   return *this; }
    DecorativeArrow& setUserRef(void* p)       { DecorativeGeometry::setUserRef(p);       return *this; }
    DecorativeArrow& setTransform(const Transform& X_BD) { DecorativeGeometry::setTransform(X_BD); return *this; }
    DecorativeArrow& setResolution(Real r)     { DecorativeGeometry::setResolution(r);    return *this; }
    DecorativeArrow& setScaleFactors(const Vec3& s) { DecorativeGeometry::setScaleFactors(s); return *this; }
    DecorativeArrow& setColor(const Vec3& rgb) { DecorativeGeometry::setColor(rgb);       return *this; }
    DecorativeArrow& setOpacity(Real o)        { DecorativeGeometry::setOpacity(o);       return *this; }
    DecorativeArrow& setLineThickness(Real t)  { DecorativeGeometry::setLineThickness(t); return *this; }
    DecorativeArrow& setRepresentation(const Representation& r)
    {
        DecorativeGeometry::setRepresentation(r); return *this;
    }
 
    SimTK_PIMPL_DOWNCAST(DecorativeArrow, DecorativeGeometry);
private:
    class DecorativeArrowRep& updRep();
    const DecorativeArrowRep& getRep() const;
};
 
 
class SimTK_SimTKCOMMON_EXPORT DecorativeCone : public DecorativeGeometry {
public:
    explicit DecorativeCone(const Vec3& p1 = Vec3(0), const UnitVec3& dir = UnitVec3(1,1,1),
        Real height = 1.0, Real baseRadius = 0.5); // Cone 
    const Vec3& getOrigin() const;
    const UnitVec3& getDirection() const;
    const Real& getHeight() const;
    const Real& getBaseRadius() const;
 
    DecorativeCone& setOrigin(const Vec3& origin);
    DecorativeCone& setDirection(const UnitVec3& direction);
    DecorativeCone& setHeight(Real length);
    DecorativeCone& setBaseRadius(Real base);
 
    // Retain the derived type when setting generic geometry options.
    DecorativeCone& setBodyId(int b)          { DecorativeGeometry::setBodyId(b);        return *this; }
    DecorativeCone& setIndexOnBody(int x)     { DecorativeGeometry::setIndexOnBody(x);   return *this; }
    DecorativeCone& setUserRef(void* p)       { DecorativeGeometry::setUserRef(p);       return *this; }
    DecorativeCone& setTransform(const Transform& X_BD) { DecorativeGeometry::setTransform(X_BD); return *this; }
    DecorativeCone& setResolution(Real r)     { DecorativeGeometry::setResolution(r);    return *this; }
    DecorativeCone& setScaleFactors(const Vec3& s) { DecorativeGeometry::setScaleFactors(s); return *this; }
    DecorativeCone& setColor(const Vec3& rgb) { DecorativeGeometry::setColor(rgb);       return *this; }
    DecorativeCone& setOpacity(Real o)        { DecorativeGeometry::setOpacity(o);       return *this; }
    DecorativeCone& setLineThickness(Real t)  { DecorativeGeometry::setLineThickness(t); return *this; }
    DecorativeCone& setRepresentation(const Representation& r)
    {
        DecorativeGeometry::setRepresentation(r); return *this;
    }
 
    SimTK_PIMPL_DOWNCAST(DecorativeCone, DecorativeGeometry);
private:
    class DecorativeConeRep& updRep();
    const DecorativeConeRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT Decorations : public DecorativeGeometry {
public:
    Decorations();
    explicit Decorations(const DecorativeGeometry& decoration);
    Decorations& addDecoration(const DecorativeGeometry& decoration);
    Decorations& addDecoration(const Transform& placement,
                               const DecorativeGeometry& decoration);
    int getNumDecorations() const;
    const DecorativeGeometry& getDecoration(int i) const;
 
    // Retain the derived type when setting generic geometry options.
    Decorations& setBodyId(int b)          {DecorativeGeometry::setBodyId(b);        return *this;}
    Decorations& setIndexOnBody(int x)     {DecorativeGeometry::setIndexOnBody(x);   return *this;}
    Decorations& setUserRef(void* p)       {DecorativeGeometry::setUserRef(p);       return *this;}
    Decorations& setTransform(const Transform& X_BD) {DecorativeGeometry::setTransform(X_BD); return *this;}
    Decorations& setResolution(Real r)     {DecorativeGeometry::setResolution(r);    return *this;}
    Decorations& setScaleFactors(const Vec3& s) {DecorativeGeometry::setScaleFactors(s); return *this;}
    Decorations& setColor(const Vec3& rgb) {DecorativeGeometry::setColor(rgb);       return *this;}
    Decorations& setOpacity(Real o)        {DecorativeGeometry::setOpacity(o);       return *this;}
    Decorations& setLineThickness(Real t)  {DecorativeGeometry::setLineThickness(t); return *this;}
    Decorations& setRepresentation(const Representation& r) 
    {   DecorativeGeometry::setRepresentation(r); return *this; }
 
 
    SimTK_PIMPL_DOWNCAST(Decorations, DecorativeGeometry);
private:
    class DecorationsRep& updRep();
    const DecorationsRep& getRep() const;
};
 
class SimTK_SimTKCOMMON_EXPORT DecorativeGeometryImplementation {
public:
    virtual ~DecorativeGeometryImplementation() { }
    virtual void implementPointGeometry(    const DecorativePoint&)    = 0;
    virtual void implementLineGeometry(     const DecorativeLine&)     = 0;
    virtual void implementBrickGeometry(    const DecorativeBrick&)    = 0;
    virtual void implementCylinderGeometry( const DecorativeCylinder&) = 0;
    virtual void implementCircleGeometry(   const DecorativeCircle&)   = 0; 
    virtual void implementSphereGeometry(   const DecorativeSphere&)   = 0;
    virtual void implementEllipsoidGeometry(const DecorativeEllipsoid&)= 0;
    virtual void implementFrameGeometry(    const DecorativeFrame&)    = 0;
    virtual void implementTextGeometry(     const DecorativeText&)     = 0;
    virtual void implementMeshGeometry(     const DecorativeMesh&)     = 0;
    virtual void implementMeshFileGeometry( const DecorativeMeshFile&) = 0;
    virtual void implementTorusGeometry(    const DecorativeTorus&)    = 0;
    virtual void implementArrowGeometry(    const DecorativeArrow&)    = 0;
    virtual void implementConeGeometry(     const DecorativeCone&)     = 0;
};
 
} // namespace SimTK
 
#endif // SimTK_SimTKCOMMON_DECORATIVE_GEOMETRY_H_