#include <PathVisualizerBase.h>

Inheritance diagram for inet::visualizer::PathVisualizerBase:

Classes
class	DirectiveResolver

class	PathVisualization

Parameters
bool	displayRoutes = false

NetworkNodeFilter	nodeFilter

PacketFilter	packetFilter

ColorSet	lineColorSet

cFigure::LineStyle	lineStyle

double	lineWidth = NaN

bool	lineSmooth = false

double	lineShift = NaN

const char *	lineShiftMode = nullptr

double	lineContactSpacing = NaN

const char *	lineContactMode = nullptr

StringFormat	labelFormat

cFigure::Font	labelFont

const char *	labelColorAsString = nullptr

cFigure::Color	labelColor

const char *	fadeOutMode = nullptr

double	fadeOutTime = NaN

double	fadeOutAnimationSpeed = NaN

simsignal_t	startPathSignal = -1

simsignal_t	extendPathSignal = -1

simsignal_t	endPathSignal = -1

LineManager *	lineManager = nullptr

std::map< std::pair< std::string, int >, std::vector< int > >	incompletePaths
	Maps path label and chunk id to module id vector. More...

std::map< int, int >	numPaths
	Maps nodes to the number of paths that go through it. More...

std::multimap< std::pair< int, int >, const PathVisualization * >	pathVisualizations
	Maps source/destination modules to multiple paths between them. More...

virtual void	initialize (int stage) override

virtual void	handleParameterChange (const char *name) override

virtual void	refreshDisplay () const override

virtual void	preDelete (cComponent *root) override

virtual void	subscribe ()

virtual void	unsubscribe ()

virtual bool	isPathStart (cModule *module) const =0

virtual bool	isPathEnd (cModule *module) const =0

virtual bool	isPathElement (cModule *module) const =0

virtual void	processPathStart (cModule networkNode, const char label, Packet *packet)

virtual void	processPathElement (cModule networkNode, const char label, Packet *packet)

virtual void	processPathEnd (cModule networkNode, const char label, Packet *packet)

virtual const PathVisualization *	createPathVisualization (const char label, const std::vector< int > &path, cPacket packet) const =0

virtual const PathVisualization *	getPathVisualization (const std::vector< int > &path)

virtual void	addPathVisualization (const PathVisualization *pathVisualization)

virtual void	removePathVisualization (const PathVisualization *pathVisualization)

virtual void	removeAllPathVisualizations ()

virtual void	setAlpha (const PathVisualization *pathVisualization, double alpha) const =0

virtual const std::vector< int > *	getIncompletePath (const std::string &label, int chunkId)

virtual void	addToIncompletePath (const std::string &label, int chunkId, cModule *module)

virtual void	removeIncompletePath (const std::string &label, int chunkId)

virtual std::string	getPathVisualizationText (const PathVisualization pathVisualization, cPacket packet) const

virtual void	refreshPathVisualization (const PathVisualization pathVisualization, cPacket packet)

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

Additional Inherited Members
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 inherited from inet::visualizer::VisualizerBase
cModule *	visualizationTargetModule = nullptr

cModule *	visualizationSubjectModule = nullptr

const char *	tags = nullptr

Member Function Documentation

◆ addPathVisualization()

void inet::visualizer::PathVisualizerBase::addPathVisualization ( const PathVisualization * pathVisualization )

protectedvirtual

Reimplemented in inet::visualizer::PathCanvasVisualizerBase, and inet::visualizer::PathOsgVisualizerBase.

 {
     auto sourceAndDestination = std::pair<int, int>(pathVisualization->moduleIds.front(), pathVisualization->moduleIds.back());
     pathVisualizations.insert(std::pair<std::pair<int, int>, const PathVisualization *>(sourceAndDestination, pathVisualization));
 }

Referenced by inet::visualizer::PathOsgVisualizerBase::addPathVisualization(), and inet::visualizer::PathCanvasVisualizerBase::addPathVisualization().

◆ addToIncompletePath()

void inet::visualizer::PathVisualizerBase::addToIncompletePath	(	const std::string &	label,
		int	chunkId,
		cModule *	module
	)

protectedvirtual

 {
     auto& moduleIds = incompletePaths[{ label, chunkId }];
     auto moduleId = module->getId();
     if (moduleIds.size() == 0 || moduleIds[moduleIds.size() - 1] != moduleId)
         moduleIds.push_back(moduleId);
 }

◆ createPathVisualization()

const PathVisualizerBase::PathVisualization * inet::visualizer::PathVisualizerBase::createPathVisualization	(	const char *	label,
		const std::vector< int > &	path,
		cPacket *	packet
	)		const

protectedpure virtual

Implemented in inet::visualizer::PathCanvasVisualizerBase, inet::visualizer::PathOsgVisualizerBase, inet::visualizer::PacketFlowCanvasVisualizer, inet::visualizer::NetworkRouteCanvasVisualizer, and inet::visualizer::TransportRouteCanvasVisualizer.

 {
     return new PathVisualization(label, path);
 }

◆ getIncompletePath()

const std::vector< int > * inet::visualizer::PathVisualizerBase::getIncompletePath	(	const std::string &	label,
		int	chunkId
	)

protectedvirtual

 {
     auto it = incompletePaths.find({ label, chunkId });
     return (it == incompletePaths.end()) ? nullptr : &it->second;
 }

◆ getPathVisualization()

const PathVisualizerBase::PathVisualization * inet::visualizer::PathVisualizerBase::getPathVisualization ( const std::vector< int > & path )

protectedvirtual

 {
     auto key = std::pair<int, int>(path.front(), path.back());
     auto range = pathVisualizations.equal_range(key);
     for (auto it = range.first; it != range.second; it++)
         if (it->second->moduleIds == path)
             return it->second;
     return nullptr;
 }

◆ getPathVisualizationText()

std::string inet::visualizer::PathVisualizerBase::getPathVisualizationText	(	const PathVisualization *	pathVisualization,
		cPacket *	packet
	)		const

protectedvirtual

 {
     DirectiveResolver directiveResolver(pathVisualization, packet);
     return labelFormat.formatString(&directiveResolver);
 }

Referenced by inet::visualizer::PathCanvasVisualizerBase::refreshPathVisualization().

◆ handleParameterChange()

void inet::visualizer::PathVisualizerBase::handleParameterChange ( const char * name )

overrideprotectedvirtual

 {
     if (!hasGUI()) return;
     if (name != nullptr) {
         if (!strcmp(name, "nodeFilter"))
             nodeFilter.setPattern(par("nodeFilter"));
         else if (!strcmp(name, "packetFilter"))
             packetFilter.setExpression(par("packetFilter").objectValue());
         removeAllPathVisualizations();
     }
 }

◆ initialize()

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

overrideprotectedvirtual

Reimplemented from inet::visualizer::VisualizerBase.

Reimplemented in inet::visualizer::PathCanvasVisualizerBase, and inet::visualizer::PathOsgVisualizerBase.

 {
     VisualizerBase::initialize(stage);
     if (!hasGUI()) return;
     if (stage == INITSTAGE_LOCAL) {
         displayRoutes = par("displayRoutes");
         nodeFilter.setPattern(par("nodeFilter"));
         packetFilter.setExpression(par("packetFilter").objectValue());
         lineColorSet.parseColors(par("lineColor"));
         lineStyle = cFigure::parseLineStyle(par("lineStyle"));
         lineWidth = par("lineWidth");
         lineSmooth = par("lineSmooth");
         lineShift = par("lineShift");
         lineShiftMode = par("lineShiftMode");
         lineContactSpacing = par("lineContactSpacing");
         lineContactMode = par("lineContactMode");
         labelFormat.parseFormat(par("labelFormat"));
         labelFont = cFigure::parseFont(par("labelFont"));
         labelColorAsString = par("labelColor");
         if (!opp_isempty(labelColorAsString))
             labelColor = cFigure::Color(labelColorAsString);
         fadeOutMode = par("fadeOutMode");
         fadeOutTime = par("fadeOutTime");
         fadeOutAnimationSpeed = par("fadeOutAnimationSpeed");
         startPathSignal = registerSignal(par("startPathSignal"));
         extendPathSignal = registerSignal(par("extendPathSignal"));
         endPathSignal = registerSignal(par("endPathSignal"));
         if (displayRoutes)
             subscribe();
     }
 }

Referenced by inet::visualizer::PathOsgVisualizerBase::initialize(), and inet::visualizer::PathCanvasVisualizerBase::initialize().

◆ isPathElement()

virtual bool inet::visualizer::PathVisualizerBase::isPathElement ( cModule * module ) const

protectedpure virtual

Implemented in inet::visualizer::PacketFlowCanvasVisualizer, inet::visualizer::NetworkRouteCanvasVisualizer, inet::visualizer::TransportRouteCanvasVisualizer, inet::visualizer::PacketFlowOsgVisualizer, inet::visualizer::NetworkRouteOsgVisualizer, and inet::visualizer::TransportRouteOsgVisualizer.

Referenced by receiveSignal().

◆ isPathEnd()

virtual bool inet::visualizer::PathVisualizerBase::isPathEnd ( cModule * module ) const

protectedpure virtual

Implemented in inet::visualizer::PacketFlowCanvasVisualizer, inet::visualizer::NetworkRouteCanvasVisualizer, inet::visualizer::TransportRouteCanvasVisualizer, inet::visualizer::PacketFlowOsgVisualizer, inet::visualizer::NetworkRouteOsgVisualizer, and inet::visualizer::TransportRouteOsgVisualizer.

Referenced by receiveSignal().

◆ isPathStart()

virtual bool inet::visualizer::PathVisualizerBase::isPathStart ( cModule * module ) const

protectedpure virtual

Implemented in inet::visualizer::PacketFlowCanvasVisualizer, inet::visualizer::NetworkRouteCanvasVisualizer, inet::visualizer::TransportRouteCanvasVisualizer, inet::visualizer::PacketFlowOsgVisualizer, inet::visualizer::NetworkRouteOsgVisualizer, and inet::visualizer::TransportRouteOsgVisualizer.

Referenced by receiveSignal().

◆ preDelete()

void inet::visualizer::PathVisualizerBase::preDelete ( cComponent * root )

overrideprotectedvirtual

 {
     if (displayRoutes) {
         unsubscribe();
         removeAllPathVisualizations();
     }
 }

◆ processPathElement()

void inet::visualizer::PathVisualizerBase::processPathElement	(	cModule *	networkNode,
		const char *	label,
		Packet *	packet
	)

protectedvirtual

Reimplemented in inet::visualizer::PacketFlowCanvasVisualizer.

 {
     mapChunks(packet->peekAt(b(0), packet->getTotalLength()), [&] (const Ptr<const Chunk>& chunk, int chunkId) {
         auto path = getIncompletePath(label, chunkId);
         if (path != nullptr)
             addToIncompletePath(label, chunkId, networkNode);
     });
 }

Referenced by receiveSignal().

◆ processPathEnd()

void inet::visualizer::PathVisualizerBase::processPathEnd	(	cModule *	networkNode,
		const char *	label,
		Packet *	packet
	)

protectedvirtual

 {
     std::set<const PathVisualization *> updatedVisualizations;
     mapChunks(packet->peekAt(b(0), packet->getTotalLength()), [&] (const Ptr<const Chunk>& chunk, int chunkId) {
         auto path = getIncompletePath(label, chunkId);
         if (path != nullptr) {
             addToIncompletePath(label, chunkId, networkNode);
             if (path->size() > 1) {
                 auto pathVisualization = getPathVisualization(*path);
                 if (pathVisualization == nullptr) {
                     pathVisualization = createPathVisualization(label, *path, packet);
                     addPathVisualization(pathVisualization);
                 }
                 pathVisualization->totalLength += chunk->getChunkLength();
                 updatedVisualizations.insert(pathVisualization);
             }
             removeIncompletePath(label, chunkId);
         }
     });
     for (auto pathVisualization : updatedVisualizations) {
         pathVisualization->numPackets++;
         refreshPathVisualization(pathVisualization, packet);
     }
 }

Referenced by receiveSignal().

◆ processPathStart()

void inet::visualizer::PathVisualizerBase::processPathStart	(	cModule *	networkNode,
		const char *	label,
		Packet *	packet
	)

protectedvirtual

 {
     mapChunks(packet->peekAt(b(0), packet->getTotalLength()), [&] (const Ptr<const Chunk>& chunk, int chunkId) {
         auto path = getIncompletePath(label, chunkId);
         if (path != nullptr)
             removeIncompletePath(label, chunkId);
         addToIncompletePath(label, chunkId, networkNode);
     });
 }

Referenced by receiveSignal().

◆ receiveSignal()

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

overridevirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signal));
  
     if (signal == startPathSignal) {
         auto module = check_and_cast<cModule *>(source);
         if (isPathStart(module)) {
             auto networkNode = getContainingNode(module);
             auto packet = check_and_cast<Packet *>(object);
             auto label = details != nullptr ? details->getName() : "";
             if (nodeFilter.matches(networkNode) && packetFilter.matches(packet))
                 processPathStart(networkNode, label, packet);
         }
     }
     else if (signal == extendPathSignal) {
         auto module = check_and_cast<cModule *>(source);
         if (isPathElement(module)) {
             auto networkNode = getContainingNode(module);
             auto packet = check_and_cast<Packet *>(object);
             auto label = details != nullptr ? details->getName() : "";
             // NOTE: nodeFilter is intentionally not applied here, because it's only important at the end points
             if (packetFilter.matches(packet))
                 processPathElement(networkNode, label, packet);
         }
     }
     else if (signal == endPathSignal) {
         auto module = check_and_cast<cModule *>(source);
         if (isPathEnd(module)) {
             auto networkNode = getContainingNode(module);
             auto packet = check_and_cast<Packet *>(object);
             auto label = details != nullptr ? details->getName() : "";
             if (nodeFilter.matches(networkNode) && packetFilter.matches(packet))
                 processPathEnd(networkNode, label, packet);
         }
     }
     else
         throw cRuntimeError("Unknown signal");
 }

◆ refreshDisplay()

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

overrideprotectedvirtual

Reimplemented in inet::visualizer::PathCanvasVisualizerBase, and inet::visualizer::PathOsgVisualizerBase.

 {
     if (fadeOutTime > 0) {
         AnimationPosition currentAnimationPosition;
         std::vector<const PathVisualization *> removedPathVisualizations;
         for (auto it : pathVisualizations) {
             auto pathVisualization = it.second;
             double delta;
             if (!strcmp(fadeOutMode, "simulationTime"))
                 delta = (currentAnimationPosition.getSimulationTime() - pathVisualization->lastUsageAnimationPosition.getSimulationTime()).dbl();
             else if (!strcmp(fadeOutMode, "animationTime"))
                 delta = currentAnimationPosition.getAnimationTime() - pathVisualization->lastUsageAnimationPosition.getAnimationTime();
             else if (!strcmp(fadeOutMode, "realTime"))
                 delta = currentAnimationPosition.getRealTime() - pathVisualization->lastUsageAnimationPosition.getRealTime();
             else
                 throw cRuntimeError("Unknown fadeOutMode: %s", fadeOutMode);
             if (delta > fadeOutTime)
                 removedPathVisualizations.push_back(pathVisualization);
             else
                 setAlpha(pathVisualization, 1 - delta / fadeOutTime);
         }
         for (auto path : removedPathVisualizations) {
             const_cast<PathVisualizerBase *>(this)->removePathVisualization(path);
             delete path;
         }
     }
 }

Referenced by inet::visualizer::PathOsgVisualizerBase::refreshDisplay(), and inet::visualizer::PathCanvasVisualizerBase::refreshDisplay().

◆ refreshPathVisualization()

void inet::visualizer::PathVisualizerBase::refreshPathVisualization	(	const PathVisualization *	pathVisualization,
		cPacket *	packet
	)

protectedvirtual

Reimplemented in inet::visualizer::PathCanvasVisualizerBase.

 {
     pathVisualization->lastUsageAnimationPosition = AnimationPosition();
 }

Referenced by inet::visualizer::PathCanvasVisualizerBase::refreshPathVisualization().

◆ removeAllPathVisualizations()

void inet::visualizer::PathVisualizerBase::removeAllPathVisualizations ( )

protectedvirtual

 {
     incompletePaths.clear();
     numPaths.clear();
     std::vector<const PathVisualization *> removedPathVisualizations;
     for (auto it : pathVisualizations)
         removedPathVisualizations.push_back(it.second);
     for (auto it : removedPathVisualizations) {
         removePathVisualization(it);
         delete it;
     }
 }

Referenced by handleParameterChange(), and preDelete().

◆ removeIncompletePath()

void inet::visualizer::PathVisualizerBase::removeIncompletePath	(	const std::string &	label,
		int	chunkId
	)

protectedvirtual

 {
     incompletePaths.erase(incompletePaths.find({ label, chunkId }));
 }

◆ removePathVisualization()

void inet::visualizer::PathVisualizerBase::removePathVisualization ( const PathVisualization * pathVisualization )

protectedvirtual

Reimplemented in inet::visualizer::PathCanvasVisualizerBase, and inet::visualizer::PathOsgVisualizerBase.

 {
     auto sourceAndDestination = std::pair<int, int>(pathVisualization->moduleIds.front(), pathVisualization->moduleIds.back());
     auto range = pathVisualizations.equal_range(sourceAndDestination);
     for (auto it = range.first; it != range.second; it++) {
         if (it->second == pathVisualization) {
             pathVisualizations.erase(it);
             break;
         }
     }
 }

Referenced by refreshDisplay(), removeAllPathVisualizations(), inet::visualizer::PathOsgVisualizerBase::removePathVisualization(), and inet::visualizer::PathCanvasVisualizerBase::removePathVisualization().

◆ setAlpha()

virtual void inet::visualizer::PathVisualizerBase::setAlpha	(	const PathVisualization *	pathVisualization,
		double	alpha
	)		const

protectedpure virtual

Implemented in inet::visualizer::PathCanvasVisualizerBase, and inet::visualizer::PathOsgVisualizerBase.

Referenced by refreshDisplay().

◆ subscribe()

void inet::visualizer::PathVisualizerBase::subscribe ( )

protectedvirtual

 {
     visualizationSubjectModule->subscribe(startPathSignal, this);
     visualizationSubjectModule->subscribe(extendPathSignal, this);
     visualizationSubjectModule->subscribe(endPathSignal, this);
 }

Referenced by initialize().

◆ unsubscribe()

void inet::visualizer::PathVisualizerBase::unsubscribe ( )

protectedvirtual

 {
     // NOTE: lookup the module again because it may have been deleted first
     auto visualizationSubjectModule = findModuleFromPar<cModule>(par("visualizationSubjectModule"), this);
     if (visualizationSubjectModule != nullptr) {
         visualizationSubjectModule->unsubscribe(startPathSignal, this);
         visualizationSubjectModule->unsubscribe(extendPathSignal, this);
         visualizationSubjectModule->unsubscribe(endPathSignal, this);
     }
 }