inet::visualizer::PhysicalEnvironmentOsgVisualizer Class Reference

#include <PhysicalEnvironmentOsgVisualizer.h>

Inheritance diagram for inet::visualizer::PhysicalEnvironmentOsgVisualizer:

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	refreshDisplay () const override
Protected Member Functions inherited from inet::visualizer::PhysicalEnvironmentVisualizerBase
Protected Member Functions inherited from inet::visualizer::VisualizerBase
virtual int	numInitStages () const override
virtual Coord	getPosition (const cModule *networkNode) const
virtual Coord	getContactPosition (const cModule *networkNode, const Coord &fromPosition, const char *contactMode, double contactSpacing) const
virtual Quaternion	getOrientation (const cModule *networkNode) const
virtual void	mapChunks (const Ptr< const Chunk > &chunk, const std::function< void(const Ptr< const Chunk > &, int)> &thunk) const

Protected Attributes
bool	enableObjectOpacity = false
Protected Attributes inherited from inet::visualizer::PhysicalEnvironmentVisualizerBase
const physicalenvironment::IPhysicalEnvironment *	physicalEnvironment = nullptr
bool	displayObjects = false
Protected Attributes inherited from inet::visualizer::VisualizerBase
cModule *	visualizationTargetModule = nullptr
cModule *	visualizationSubjectModule = nullptr
const char *	tags = nullptr

Member Function Documentation

initialize()

void inet::visualizer::PhysicalEnvironmentOsgVisualizer::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::visualizer::PhysicalEnvironmentVisualizerBase.

{
    PhysicalEnvironmentVisualizerBase::initialize(stage);
    if (!hasGUI()) return;
    if (stage == INITSTAGE_LOCAL)
        enableObjectOpacity = par("enableObjectOpacity");
}

refreshDisplay()

void inet::visualizer::PhysicalEnvironmentOsgVisualizer::refreshDisplay ( ) const

overrideprotectedvirtual

{
    // only update after initialize
    if (physicalEnvironment != nullptr && getSimulation()->getEventNumber() == 0 && displayObjects) {
        auto scene = inet::osg::TopLevelScene::getSimulationScene(visualizationTargetModule);
        for (int i = 0; i < physicalEnvironment->getNumObjects(); i++) {
            const IPhysicalObject *object = physicalEnvironment->getObject(i);
            const ShapeBase *shape = object->getShape();
            const Coord& position = object->getPosition();
            const Quaternion& orientation = object->getOrientation();
            const RotationMatrix rotation(orientation.toEulerAngles());
            const double opacity = enableObjectOpacity ? object->getOpacity() : 1.0;
            // cuboid
            const Cuboid *cuboid = dynamic_cast<const Cuboid *>(shape);
            if (cuboid != nullptr) {
                auto size = cuboid->getSize();
                auto drawable = new osg::ShapeDrawable(new osg::Box(osg::Vec3d(0, 0, 0), size.x, size.y, size.z));
                auto stateSet = inet::osg::createStateSet(object->getFillColor(), opacity);
                drawable->setStateSet(stateSet);
                auto geode = new osg::Geode();
                geode->addDrawable(drawable);
                auto pat = inet::osg::createPositionAttitudeTransform(position, orientation);
                pat->addChild(geode);
                scene->addChild(pat);
            }
            // sphere
            const Sphere *sphere = dynamic_cast<const Sphere *>(shape);
            if (sphere != nullptr) {
                double radius = sphere->getRadius();
                auto drawable = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(position.x, position.y, position.z), radius));
                drawable->setStateSet(inet::osg::createStateSet(object->getFillColor(), opacity));
                auto geode = new osg::Geode();
                geode->addDrawable(drawable);
                scene->addChild(geode);
            }
            // prism
            const Prism *prism = dynamic_cast<const Prism *>(shape);
            if (prism != nullptr) {
                auto geode = new osg::Geode();
                auto stateSet = inet::osg::createStateSet(object->getFillColor(), opacity);
                auto bottomFace = inet::osg::createPolygonGeometry(prism->getBase().getPoints());
                bottomFace->setStateSet(stateSet);
                auto topFace = inet::osg::createPolygonGeometry(prism->getBase().getPoints(), Coord(0, 0, prism->getHeight()));
                topFace->setStateSet(stateSet);
                geode->addDrawable(bottomFace);
                geode->addDrawable(topFace);
                for (auto face : prism->getFaces()) {
                    auto sideFace = inet::osg::createPolygonGeometry(face.getPoints());
                    sideFace->setStateSet(stateSet);
                    geode->addDrawable(sideFace);
                }
                auto pat = inet::osg::createPositionAttitudeTransform(position, orientation);
                pat->addChild(geode);
                scene->addChild(pat);
            }
            // polyhedron
            const Polyhedron *polyhedron = dynamic_cast<const Polyhedron *>(shape);
            if (polyhedron != nullptr) {
                auto geode = new osg::Geode();
                auto stateSet = inet::osg::createStateSet(object->getFillColor(), opacity);
                for (auto face : polyhedron->getFaces()) {
                    auto geometry = new osg::Geometry();
                    auto vertices = new osg::Vec3Array();
                    for (auto edge : face->getEdges())
                        vertices->push_back(osg::Vec3d(edge->getP1()->x, edge->getP1()->y, edge->getP1()->z));
                    geometry->setVertexArray(vertices);
                    geometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POLYGON, 0, face->getEdges().size()));
                    geometry->setStateSet(stateSet);
                    geode->addDrawable(geometry);
                }
                auto pat = inet::osg::createPositionAttitudeTransform(position, orientation);
                pat->addChild(geode);
                scene->addChild(pat);
            }
        }
    }
}

Member Data Documentation

enableObjectOpacity

bool inet::visualizer::PhysicalEnvironmentOsgVisualizer::enableObjectOpacity = false

protected

---

The documentation for this class was generated from the following files:

• PhysicalEnvironmentOsgVisualizer.h
• PhysicalEnvironmentOsgVisualizer.cc