#include <MobilityCanvasVisualizer.h>

Inheritance diagram for inet::visualizer::MobilityCanvasVisualizer:

Classes
class	MobilityCanvasVisualization

Public Member Functions
virtual	~MobilityCanvasVisualizer ()

virtual void	receiveSignal (cComponent source, simsignal_t signal, cObject object, cObject *details) override

Public Member Functions inherited from inet::visualizer::MobilityVisualizerBase
virtual	~MobilityVisualizerBase ()

Static Public Member Functions
static void	setPosition (cModule *visualRepresentation, cFigure::Point position)

Protected Member Functions
virtual void	initialize (int stage) override

virtual void	refreshDisplay () const override

virtual cModule *	findVisualRepresentation (cModule *module) const

virtual MobilityCanvasVisualization *	getMobilityVisualization (const IMobility *mobility) const

virtual void	setMobilityVisualization (const IMobility mobility, MobilityCanvasVisualization entry)

virtual void	removeMobilityVisualization (const IMobility *mobility)

virtual MobilityCanvasVisualization *	ensureMobilityVisualization (IMobility *mobility)

virtual void	extendMovementTrail (const IMobility mobility, TrailFigure trailFigure, cFigure::Point position) const

Protected Member Functions inherited from inet::visualizer::MobilityVisualizerBase
virtual void	handleParameterChange (const char *name) override

virtual void	subscribe ()

virtual void	unsubscribe ()

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 InterfaceEntry *	getInterfaceEntry (cModule networkNode, cModule module) const

Protected Attributes
double	zIndex = NaN

const CanvasProjection *	canvasProjection = nullptr

NetworkNodeCanvasVisualizer *	networkNodeVisualizer = nullptr

std::map< const IMobility , MobilityCanvasVisualization >	mobilityVisualizations

Protected Attributes inherited from inet::visualizer::MobilityVisualizerBase
bool	displayMovements = false

double	animationSpeed = NaN

ModuleFilter	moduleFilter

bool	displayOrientations = false

double	orientationArcSize = NaN

cFigure::Color	orientationLineColor

cFigure::LineStyle	orientationLineStyle

double	orientationLineWidth = NaN

bool	displayVelocities = false

double	velocityArrowScale = NaN

cFigure::Color	velocityLineColor

cFigure::LineStyle	velocityLineStyle

double	velocityLineWidth = NaN

bool	displayMovementTrails = false

bool	autoMovementTrailLineColor = false

ColorSet	movementTrailLineColorSet

cFigure::LineStyle	movementTrailLineStyle

double	movementTrailLineWidth = NaN

int	trailLength = -1

Protected Attributes inherited from inet::visualizer::VisualizerBase
cModule *	visualizerTargetModule = nullptr

const char *	tags = nullptr

Constructor & Destructor Documentation

inet::visualizer::MobilityCanvasVisualizer::~MobilityCanvasVisualizer ( )

virtual

 {
     for (auto mobilityVisualization : mobilityVisualizations)
         delete mobilityVisualization.second;
 }

Member Function Documentation

MobilityCanvasVisualizer::MobilityCanvasVisualization * inet::visualizer::MobilityCanvasVisualizer::ensureMobilityVisualization ( IMobility * mobility )

protectedvirtual

Referenced by receiveSignal().

 {
     auto mobilityVisualization = getMobilityVisualization(mobility);
     if (mobilityVisualization == nullptr) {
         auto canvas = visualizerTargetModule->getCanvas();
         auto module = const_cast<cModule *>(dynamic_cast<const cModule *>(mobility));
         auto visualRepresentation = findVisualRepresentation(module);
         auto visualization = networkNodeVisualizer->getNetworkNodeVisualization(getContainingNode(module));
         cArcFigure *orientationFigure = nullptr;
         if (displayOrientations) {
             auto rectangle = getSimulation()->getEnvir()->getSubmoduleBounds(visualRepresentation);
             int radius = rectangle.getSize().getLength() * 1.25 / 2;
             orientationFigure = new cArcFigure("orientation");
             orientationFigure->setTags((std::string("orientation ") + tags).c_str());
             orientationFigure->setTooltip("This arc represents the current orientation of the mobility model");
             orientationFigure->setZIndex(zIndex);
             orientationFigure->setBounds(cFigure::Rectangle(-radius, -radius, 2 * radius, 2 * radius));
             orientationFigure->setLineColor(orientationLineColor);
             orientationFigure->setLineStyle(orientationLineStyle);
             orientationFigure->setLineWidth(orientationLineWidth);
             visualization->addFigure(orientationFigure);
         }
         cLineFigure *velocityFigure = nullptr;
         if (displayVelocities) {
             velocityFigure = new cLineFigure("velocity");
             velocityFigure->setTags((std::string("velocity ") + tags).c_str());
             velocityFigure->setTooltip("This arrow represents the current velocity of the mobility model");
             velocityFigure->setZIndex(zIndex);
             velocityFigure->setVisible(false);
             velocityFigure->setEndArrowhead(cFigure::ARROW_SIMPLE);
             velocityFigure->setLineColor(velocityLineColor);
             velocityFigure->setLineStyle(velocityLineStyle);
             velocityFigure->setLineWidth(velocityLineWidth);
             visualization->addFigure(velocityFigure);
         }
         TrailFigure *trailFigure = nullptr;
         if (displayMovementTrails) {
             trailFigure = new TrailFigure(trailLength, true, "movement trail");
             trailFigure->setTags((std::string("movement_trail recent_history ") + tags).c_str());
             trailFigure->setZIndex(zIndex);
             canvas->addFigure(trailFigure);
         }
         mobilityVisualization = new MobilityCanvasVisualization(visualization, visualRepresentation, orientationFigure, velocityFigure, trailFigure, mobility);
         setMobilityVisualization(mobility, mobilityVisualization);
     }
     return mobilityVisualization;
 }

void inet::visualizer::MobilityCanvasVisualizer::extendMovementTrail	(	const IMobility *	mobility,
		TrailFigure *	trailFigure,
		cFigure::Point	position
	)		const

protectedvirtual

Referenced by refreshDisplay().

 {
     cFigure::Point startPosition;
     cFigure::Point endPosition = position;
     if (trailFigure->getNumFigures() == 0)
         startPosition = position;
     else
         startPosition = static_cast<cLineFigure*>(trailFigure->getFigure(trailFigure->getNumFigures() - 1))->getEnd();
     double dx = startPosition.x - endPosition.x;
     double dy = startPosition.y - endPosition.y;
     // TODO: 1?
     if (trailFigure->getNumFigures() == 0 || dx * dx + dy * dy > 1) {
         cLineFigure *movementLine = new cLineFigure("movementTrail");
         movementLine->setTags((std::string("movement_trail recent_history ") + tags).c_str());
         movementLine->setTooltip("This line represents the recent movement trail of the mobility model");
         movementLine->setStart(startPosition);
         movementLine->setEnd(endPosition);
         auto module = const_cast<cModule *>(check_and_cast<const cModule *>(mobility));
         movementLine->setLineColor(movementTrailLineColorSet.getColor(module->getId()));
         movementLine->setLineStyle(movementTrailLineStyle);
         movementLine->setLineWidth(movementTrailLineWidth);
         movementLine->setZoomLineWidth(false);
         trailFigure->addFigure(movementLine);
     }
 }

cModule * inet::visualizer::MobilityCanvasVisualizer::findVisualRepresentation ( cModule * module ) const

protectedvirtual

Referenced by ensureMobilityVisualization().

 {
     while (module != nullptr && module->getParentModule() != visualizerTargetModule)
         module = module->getParentModule();
     return module;
 }

MobilityCanvasVisualizer::MobilityCanvasVisualization * inet::visualizer::MobilityCanvasVisualizer::getMobilityVisualization ( const IMobility * mobility ) const

protectedvirtual

Referenced by ensureMobilityVisualization().

 {
     auto it = mobilityVisualizations.find(mobility);
     if (it == mobilityVisualizations.end())
         return nullptr;
     else
         return it->second;
 }

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

overrideprotectedvirtual

Reimplemented from inet::visualizer::MobilityVisualizerBase.

 {
     MobilityVisualizerBase::initialize(stage);
     if (!hasGUI()) return;
     if (stage == INITSTAGE_PHYSICAL_ENVIRONMENT) {
         zIndex = par("zIndex");
         canvasProjection = CanvasProjection::getCanvasProjection(visualizerTargetModule->getCanvas());
         networkNodeVisualizer = getModuleFromPar<NetworkNodeCanvasVisualizer>(par("networkNodeVisualizerModule"), this);
     }
 }

void inet::visualizer::MobilityCanvasVisualizer::receiveSignal	(	cComponent *	source,
		simsignal_t	signal,
		cObject *	object,
		cObject *	details
	)

overridevirtual

 {
     Enter_Method_Silent();
     if (signal == IMobility::mobilityStateChangedSignal) {
         if (moduleFilter.matches(check_and_cast<cModule *>(source)))
             ensureMobilityVisualization(dynamic_cast<IMobility *>(source));
     }
     else
         throw cRuntimeError("Unknown signal");
 }

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

overrideprotectedvirtual

 {
     MobilityVisualizerBase::refreshDisplay();
     for (auto it : mobilityVisualizations) {
         auto mobilityVisualization = it.second;
         auto mobility = mobilityVisualization->mobility;
         auto position = canvasProjection->computeCanvasPoint(mobility->getCurrentPosition());
         auto orientation = mobility->getCurrentAngularPosition();
         auto velocity = canvasProjection->computeCanvasPoint(mobility->getCurrentSpeed());
         mobilityVisualization->networkNodeVisualization->setTransform(cFigure::Transform().translate(position.x, position.y));
         if (mobilityVisualization->visualRepresentation != nullptr)
             setPosition(mobilityVisualization->visualRepresentation, position);
         if (displayOrientations) {
             // TODO: this doesn't correctly take canvas projection into account
             double angle = orientation.alpha;
             mobilityVisualization->orientationFigure->setStartAngle(angle - M_PI * orientationArcSize);
             mobilityVisualization->orientationFigure->setEndAngle(angle + M_PI * orientationArcSize);
         }
         if (displayVelocities) {
             mobilityVisualization->veloctiyFigure->setEnd(velocity * velocityArrowScale);
             mobilityVisualization->veloctiyFigure->setVisible(velocity.getLength() != 0);
         }
         if (displayMovementTrails)
             extendMovementTrail(mobility, mobilityVisualization->trailFigure, position);
     }
     visualizerTargetModule->getCanvas()->setAnimationSpeed(mobilityVisualizations.empty() ? 0 : animationSpeed, this);
 }

void inet::visualizer::MobilityCanvasVisualizer::removeMobilityVisualization ( const IMobility * mobility )

protectedvirtual

 {
     mobilityVisualizations.erase(mobility);
 }

void inet::visualizer::MobilityCanvasVisualizer::setMobilityVisualization	(	const IMobility *	mobility,
		MobilityCanvasVisualization *	entry
	)

protectedvirtual

Referenced by ensureMobilityVisualization().

 {
     mobilityVisualizations[mobility] = entry;
 }

void inet::visualizer::MobilityCanvasVisualizer::setPosition	(	cModule *	visualRepresentation,
		cFigure::Point	position
	)

static

Referenced by refreshDisplay(), and inet::MobilityBase::updateVisualRepresentation().

 {
     char buf[32];
     snprintf(buf, sizeof(buf), "%lf", position.x);
     buf[sizeof(buf) - 1] = 0;
     visualRepresentation->getDisplayString().setTagArg("p", 0, buf);
     snprintf(buf, sizeof(buf), "%lf", position.y);
     buf[sizeof(buf) - 1] = 0;
     visualRepresentation->getDisplayString().setTagArg("p", 1, buf);
 }