#include <MediumCanvasVisualizer.h>

Inheritance diagram for inet::visualizer::MediumCanvasVisualizer:

Protected Member Functions
virtual void	initialize (int stage) override

virtual void	refreshDisplay () const override

virtual void	setAnimationSpeed ()

virtual cFigure *	getTransmissionFigure (const IRadio *radio) const

virtual void	setTransmissionFigure (const IRadio radio, cFigure figure)

virtual cFigure *	removeTransmissionFigure (const IRadio *radio)

virtual cFigure *	getReceptionFigure (const IRadio *radio) const

virtual void	setReceptionFigure (const IRadio radio, cFigure figure)

virtual cFigure *	removeReceptionFigure (const IRadio *radio)

virtual cFigure *	getSignalFigure (const ITransmission *transmission) const

virtual void	setSignalFigure (const ITransmission transmission, cFigure figure)

virtual cFigure *	removeSignalFigure (const ITransmission *transmission)

virtual cGroupFigure *	createSignalFigure (const ITransmission *transmission) const

virtual void	refreshSignalFigure (const ITransmission *transmission) const

virtual void	radioAdded (const IRadio *radio) override

virtual void	radioRemoved (const IRadio *radio) override

virtual void	transmissionAdded (const ITransmission *transmission) override

virtual void	transmissionRemoved (const ITransmission *transmission) override

virtual void	transmissionStarted (const ITransmission *transmission) override

virtual void	transmissionEnded (const ITransmission *transmission) override

virtual void	receptionStarted (const IReception *reception) override

virtual void	receptionEnded (const IReception *reception) override

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

virtual bool	isSignalPropagationInProgress (const ITransmission *transmission) const

virtual bool	isSignalTransmissionInProgress (const ITransmission *transmission) const

virtual bool	matchesTransmission (const ITransmission *transmission) const

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
Parameters
double	zIndex = NaN

const CanvasProjection *	canvasProjection = nullptr

SignalShape	signalShape = SIGNAL_SHAPE_RING

double	signalOpacity = NaN

int	signalRingCount = -1

double	signalRingSize = NaN

double	signalFadingDistance = NaN

double	signalFadingFactor = NaN

int	signalWaveCount = -1

double	signalWaveLength = NaN

double	signalWaveWidth = NaN

double	signalWaveFadingAnimationSpeedFactor = NaN

bool	displayCommunicationHeat = false

int	communicationHeatMapSize = 100

Figures
cGroupFigure *	signalLayer = nullptr
	The layer figure that contains the figures representing the ongoing communications. More...

HeatMapFigure *	communicationHeat = nullptr
	The heat map figure that shows the recent successful communications. More...

Protected Attributes inherited from inet::visualizer::MediumVisualizerBase
IRadioMedium *	radioMedium = nullptr

NetworkNodeFilter	networkNodeFilter

InterfaceFilter	interfaceFilter

PacketFilter	packetFilter

bool	displaySignals = false

ColorSet	signalColorSet

double	signalPropagationAnimationSpeed = NaN

double	signalPropagationAnimationTime = NaN

double	signalPropagationAdditionalTime = NaN

double	signalTransmissionAnimationSpeed = NaN

double	signalTransmissionAnimationTime = NaN

double	signalAnimationSpeedChangeTime = NaN

bool	displayTransmissions = false

bool	displayReceptions = false

Displacement	transmissionDisplacementHint

Displacement	receptionDisplacementHint

double	transmissionDisplacementPriority

double	receptionDisplacementPriority

bool	displayInterferenceRanges = false

cFigure::Color	interferenceRangeLineColor

cFigure::LineStyle	interferenceRangeLineStyle

double	interferenceRangeLineWidth = NaN

bool	displayCommunicationRanges = false

cFigure::Color	communicationRangeLineColor

cFigure::LineStyle	communicationRangeLineStyle

double	communicationRangeLineWidth = NaN

double	defaultSignalPropagationAnimationSpeed = NaN

double	defaultSignalTransmissionAnimationSpeed = NaN

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

const char *	tags = nullptr

Internal state
enum	SignalInProgress { SIP_NONE, SIP_PROPAGATION, SIP_TRANSMISSION }

SignalInProgress	lastSignalInProgress = SIP_NONE

AnimationSpeedInterpolator	animationSpeedInterpolator

NetworkNodeCanvasVisualizer *	networkNodeVisualizer = nullptr

std::vector< const ITransmission * >	transmissions
	The list of ongoing transmissions. More...

std::map< const IRadio , cFigure >	transmissionFigures
	The list of transmission figures. More...

std::map< const IRadio , cFigure >	receptionFigures
	The list of reception figures. More...

std::map< const ITransmission , cFigure >	signalFigures
	The propagating signal figures. More...

Additional Inherited Members
Public Member Functions inherited from inet::visualizer::MediumVisualizerBase
virtual	~MediumVisualizerBase ()

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

Protected Types inherited from inet::visualizer::MediumVisualizerBase
enum	SignalShape { SIGNAL_SHAPE_RING, SIGNAL_SHAPE_SPHERE, SIGNAL_SHAPE_BOTH }

Member Enumeration Documentation

enum inet::visualizer::MediumCanvasVisualizer::SignalInProgress

protected

Enumerator
SIP_NONE
SIP_PROPAGATION
SIP_TRANSMISSION

                           {
         SIP_NONE,
         SIP_PROPAGATION,
         SIP_TRANSMISSION,
     };

Member Function Documentation

cGroupFigure * inet::visualizer::MediumCanvasVisualizer::createSignalFigure ( const ITransmission * transmission ) const

protectedvirtual

Referenced by transmissionAdded().

 {
     cFigure::Point position = canvasProjection->computeCanvasPoint( transmission->getStartPosition());
     cGroupFigure* groupFigure = new cGroupFigure("signal");
     cFigure::Color color = signalColorSet.getColor(transmission->getId());
     SignalFigure* signalFigure = new SignalFigure("bubble");
     signalFigure->setTags((std::string("propagating_signal ") + tags).c_str());
     signalFigure->setTooltip("These rings represents a signal propagating through the medium");
     signalFigure->setAssociatedObject(const_cast<cObject *>(check_and_cast<const cObject *>(transmission)));
     signalFigure->setRingCount(signalRingCount);
     signalFigure->setRingSize(signalRingSize);
     signalFigure->setFadingDistance(signalFadingDistance);
     signalFigure->setFadingFactor(signalFadingFactor);
     signalFigure->setWaveCount(signalWaveCount);
     signalFigure->setWaveLength(signalWaveLength);
     signalFigure->setWaveWidth(signalWaveWidth);
     signalFigure->setOpacity(signalOpacity);
     signalFigure->setColor(color);
     signalFigure->setBounds(cFigure::Rectangle(position.x, position.y, 0, 0));
     signalFigure->refresh();
     groupFigure->addFigure(signalFigure);
     cLabelFigure* nameFigure = new cLabelFigure("packet name");
     nameFigure->setPosition(position);
     nameFigure->setTags((std::string("propagating_signal packet_name label ") + tags).c_str());
     nameFigure->setText(transmission->getMacFrame()->getName());
     nameFigure->setColor(color);
     groupFigure->addFigure(nameFigure);
     return groupFigure;
 }

cFigure * inet::visualizer::MediumCanvasVisualizer::getReceptionFigure ( const IRadio * radio ) const

protectedvirtual

Referenced by receptionEnded(), and receptionStarted().

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

cFigure * inet::visualizer::MediumCanvasVisualizer::getSignalFigure ( const ITransmission * transmission ) const

protectedvirtual

Referenced by refreshSignalFigure(), and transmissionRemoved().

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

cFigure * inet::visualizer::MediumCanvasVisualizer::getTransmissionFigure ( const IRadio * radio ) const

protectedvirtual

Referenced by transmissionEnded(), and transmissionStarted().

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

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

overrideprotectedvirtual

Reimplemented from inet::visualizer::MediumVisualizerBase.

 {
     MediumVisualizerBase::initialize(stage);
     if (!hasGUI()) return;
     if (stage == INITSTAGE_LOCAL) {
         zIndex = par("zIndex");
         const char *signalShapeString = par("signalShape");
         if (!strcmp(signalShapeString, "ring"))
             signalShape = SIGNAL_SHAPE_RING;
         else if (!strcmp(signalShapeString, "sphere"))
             signalShape = SIGNAL_SHAPE_SPHERE;
         else
             throw cRuntimeError("Unknown signalShape parameter value: '%s'", signalShapeString);
         signalOpacity = par("signalOpacity");
         signalRingCount = par("signalRingCount");
         signalRingSize = par("signalRingSize");
         signalFadingDistance = par("signalFadingDistance");
         signalFadingFactor = par("signalFadingFactor");
         signalWaveCount = par("signalWaveCount");
         signalWaveLength = par("signalWaveLength");
         signalWaveWidth = par("signalWaveWidth");
         signalWaveFadingAnimationSpeedFactor = par("signalWaveFadingAnimationSpeedFactor");
         cCanvas *canvas = visualizerTargetModule->getCanvas();
         if (displaySignals) {
             signalLayer = new cGroupFigure("communication");
             signalLayer->setZIndex(zIndex);
             signalLayer->insertBelow(canvas->getSubmodulesLayer());
         }
         displayCommunicationHeat = par("displayCommunicationHeat");
         if (displayCommunicationHeat) {
             communicationHeat = new HeatMapFigure(communicationHeatMapSize, "communication heat");
             communicationHeat->setZIndex(zIndex);
             communicationHeat->setTags((std::string("successful_reception heat ") + tags).c_str());
             canvas->addFigure(communicationHeat, 0);
         }
         animationSpeedInterpolator.setCurrentAnimationSpeed(0);
         animationSpeedInterpolator.setTargetAnimationSpeed(AnimationPosition::REAL_TIME, 0, 0);
         networkNodeVisualizer = getModuleFromPar<NetworkNodeCanvasVisualizer>(par("networkNodeVisualizerModule"), this);
     }
     else if (stage == INITSTAGE_LAST) {
         canvasProjection = CanvasProjection::getCanvasProjection(visualizerTargetModule->getCanvas());
         if (communicationHeat != nullptr) {
             const IMediumLimitCache *mediumLimitCache = radioMedium->getMediumLimitCache();
             Coord min = mediumLimitCache->getMinConstraintArea();
             Coord max = mediumLimitCache->getMaxConstraintArea();
             cFigure::Point o = canvasProjection->computeCanvasPoint(Coord::ZERO);
             cFigure::Point x = canvasProjection->computeCanvasPoint(Coord(1, 0, 0));
             cFigure::Point y = canvasProjection->computeCanvasPoint(Coord(0, 1, 0));
             double t1 = o.x;
             double t2 = o.y;
             double a = x.x - t1;
             double b = x.y - t2;
             double c = y.x - t1;
             double d = y.y - t2;
             communicationHeat->setTransform(cFigure::Transform(a, b, c, d, t1, t2));
             communicationHeat->setPosition(cFigure::Point((min.x + max.x) / 2, (min.y + max.y) / 2));
             communicationHeat->setWidth(max.x - min.x);
             communicationHeat->setHeight(max.y - min.y);
         }
     }
 }

void inet::visualizer::MediumCanvasVisualizer::radioAdded ( const IRadio * radio )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     auto module = check_and_cast<const cModule *>(radio);
     auto networkNode = getContainingNode(module);
     if (networkNodeFilter.matches(networkNode)) {
         if (displayInterferenceRanges || (module->hasPar("displayInterferenceRange") && module->par("displayInterferenceRange"))) {
             auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
             auto interferenceRangeFigure = new cOvalFigure("interferenceRange");
             m maxInterferenceRange = check_and_cast<const IRadioMedium *>(radio->getMedium())->getMediumLimitCache()->getMaxInterferenceRange(radio);
             interferenceRangeFigure->setTags((std::string("interference_range ") + tags).c_str());
             interferenceRangeFigure->setTooltip("This circle represents the interference range of a wireless interface");
             interferenceRangeFigure->setBounds(cFigure::Rectangle(-maxInterferenceRange.get(), -maxInterferenceRange.get(), 2 * maxInterferenceRange.get(), 2 * maxInterferenceRange.get()));
             interferenceRangeFigure->setLineColor(interferenceRangeLineColor);
             interferenceRangeFigure->setLineStyle(interferenceRangeLineStyle);
             interferenceRangeFigure->setLineWidth(interferenceRangeLineWidth);
             networkNodeVisualization->addFigure(interferenceRangeFigure);
         }
         if (displayCommunicationRanges || (module->hasPar("displayCommunicationRange") && module->par("displayCommunicationRange"))) {
             auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
             auto communicationRangeFigure = new cOvalFigure("communicationRange");
             m maxCommunicationRange = check_and_cast<const IRadioMedium *>(radio->getMedium())->getMediumLimitCache()->getMaxCommunicationRange(radio);
             communicationRangeFigure->setTags((std::string("communication_range ") + tags).c_str());
             communicationRangeFigure->setTooltip("This circle represents the communication range of a wireless interface");
             communicationRangeFigure->setBounds(cFigure::Rectangle(-maxCommunicationRange.get(), -maxCommunicationRange.get(), 2 * maxCommunicationRange.get(), 2 * maxCommunicationRange.get()));
             communicationRangeFigure->setLineColor(communicationRangeLineColor);
             communicationRangeFigure->setLineStyle(communicationRangeLineStyle);
             communicationRangeFigure->setLineWidth(communicationRangeLineWidth);
             networkNodeVisualization->addFigure(communicationRangeFigure);
         }
         if (displayTransmissions || displayReceptions) {
             auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
             if (displayTransmissions) {
                 std::string imageName = par("transmissionImage");
                 auto transmissionFigure = new LabeledIconFigure("transmission");
                 transmissionFigure->setTags((std::string("transmission ") + tags).c_str());
                 transmissionFigure->setTooltip("This icon represents an ongoing transmission in a wireless interface");
                 transmissionFigure->setVisible(false);
                 auto iconFigure = transmissionFigure->getIconFigure();
                 iconFigure->setImageName(imageName.substr(0, imageName.find_first_of(".")).c_str());
                 iconFigure->setAnchor(cFigure::ANCHOR_NW);
                 auto labelFigure = transmissionFigure->getLabelFigure();
                 labelFigure->setPosition(iconFigure->getBounds().getSize() / 2);
                 networkNodeVisualization->addAnnotation(transmissionFigure, transmissionFigure->getBounds().getSize(), transmissionDisplacementHint, transmissionDisplacementPriority);
                 setTransmissionFigure(radio, transmissionFigure);
             }
             if (displayReceptions) {
                 std::string imageName = par("receptionImage");
                 auto receptionFigure = new LabeledIconFigure("reception");
                 receptionFigure->setTags((std::string("reception ") + tags).c_str());
                 receptionFigure->setTooltip("This icon represents an ongoing reception in a wireless interface");
                 receptionFigure->setVisible(false);
                 auto iconFigure = receptionFigure->getIconFigure();
                 iconFigure->setImageName(imageName.substr(0, imageName.find_first_of(".")).c_str());
                 iconFigure->setAnchor(cFigure::ANCHOR_NW);
                 auto labelFigure = receptionFigure->getLabelFigure();
                 labelFigure->setPosition(iconFigure->getBounds().getSize() / 2);
                 networkNodeVisualization->addAnnotation(receptionFigure, receptionFigure->getBounds().getSize(), receptionDisplacementHint, receptionDisplacementPriority);
                 setReceptionFigure(radio, receptionFigure);
             }
         }
     }
 }

void inet::visualizer::MediumCanvasVisualizer::radioRemoved ( const IRadio * radio )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     auto transmissionFigure = removeTransmissionFigure(radio);
     if (transmissionFigure != nullptr) {
         auto module = const_cast<cModule *>(check_and_cast<const cModule *>(radio));
         auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(getContainingNode(module));
         networkNodeVisualization->removeAnnotation(transmissionFigure);
     }
     auto figure = removeReceptionFigure(radio);
     if (figure != nullptr) {
         auto module = const_cast<cModule *>(check_and_cast<const cModule *>(radio));
         auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(getContainingNode(module));
         networkNodeVisualization->removeAnnotation(figure);
     }
 }

void inet::visualizer::MediumCanvasVisualizer::receptionEnded ( const IReception * reception )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (matchesTransmission(reception->getTransmission())) {
         if (displaySignals)
             setAnimationSpeed();
         if (displayReceptions) {
             auto receiver = reception->getReceiver();
             if (networkNodeFilter.matches(check_and_cast<const cModule *>(receiver))) {
                 auto figure = getReceptionFigure(receiver);
                 auto networkNode = getContainingNode(check_and_cast<const cModule *>(receiver));
                 auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
                 networkNodeVisualization->setAnnotationVisible(figure, false);
             }
         }
     }
 }

void inet::visualizer::MediumCanvasVisualizer::receptionStarted ( const IReception * reception )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (matchesTransmission(reception->getTransmission())) {
         if (displaySignals)
             setAnimationSpeed();
         if (displayReceptions) {
             auto receiver = reception->getReceiver();
             if (networkNodeFilter.matches(check_and_cast<const cModule *>(receiver))) {
                 auto figure = getReceptionFigure(receiver);
                 auto networkNode = getContainingNode(check_and_cast<const cModule *>(receiver));
                 auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
                 networkNodeVisualization->setAnnotationVisible(figure, true);
                 auto labelFigure = check_and_cast<LabeledIconFigure *>(figure)->getLabelFigure();
 #ifdef WITH_RADIO
                 if (auto scalarReception = dynamic_cast<const ScalarReception *>(reception)) {
                     char tmp[32];
                     sprintf(tmp, "%.4g dBW", inet::math::fraction2dB(W(scalarReception->getPower()).get()));
                     labelFigure->setText(tmp);
                 }
                 else
 #endif // WITH_RADIO
                     labelFigure->setText("");
             }
         }
         if (displayCommunicationHeat) {
             const ITransmission *transmission = reception->getTransmission();
             const IMediumLimitCache *mediumLimitCache = radioMedium->getMediumLimitCache();
             Coord min = mediumLimitCache->getMinConstraintArea();
             Coord max = mediumLimitCache->getMaxConstraintArea();
             Coord delta = max - min;
             int x1 = std::round((communicationHeatMapSize - 1) * ((transmission->getStartPosition().x - min.x) / delta.x));
             int y1 = std::round((communicationHeatMapSize - 1) * ((transmission->getStartPosition().y - min.x) / delta.y));
             int x2 = std::round((communicationHeatMapSize - 1) * ((reception->getStartPosition().x - min.x) / delta.x));
             int y2 = std::round((communicationHeatMapSize - 1) * ((reception->getStartPosition().y - min.y) / delta.y));
             communicationHeat->heatLine(x1, y1, x2, y2);
         }
     }
 }

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

overrideprotectedvirtual

 {
     if (displaySignals) {
         for (auto transmission : transmissions)
             if (matchesTransmission(transmission))
                 refreshSignalFigure(transmission);
         const_cast<MediumCanvasVisualizer *>(this)->setAnimationSpeed();
     }
     if (displayCommunicationHeat)
         communicationHeat->coolDown();
 }

void inet::visualizer::MediumCanvasVisualizer::refreshSignalFigure ( const ITransmission * transmission ) const

protectedvirtual

Referenced by refreshDisplay().

 {
     const IPropagation *propagation = radioMedium->getPropagation();
     cFigure *groupFigure = getSignalFigure(transmission);
     double startRadius = propagation->getPropagationSpeed().get() * (simTime() - transmission->getStartTime()).dbl();
     double endRadius = std::max(0.0, propagation->getPropagationSpeed().get() * (simTime() - transmission->getEndTime()).dbl());
     if (groupFigure) {
         SignalFigure *signalFigure = static_cast<SignalFigure *>(groupFigure->getFigure(0));
         cLabelFigure *labelFigure = static_cast<cLabelFigure *>(groupFigure->getFigure(1));
         double phi = transmission->getId();
         labelFigure->setTransform(cFigure::Transform().translate(endRadius * sin(phi), endRadius * cos(phi)));
         const Coord transmissionStart = transmission->getStartPosition();
         // KLUDGE: to workaround overflow bugs in drawing
         double offset = std::fmod(startRadius, signalFigure->getWaveLength());
         if (startRadius > 10000)
             startRadius = 10000;
         if (endRadius > 10000)
             endRadius = 10000;
         switch (signalShape) {
             case SIGNAL_SHAPE_RING: {
                 // determine the rotated 2D canvas points by computing the 2D affine transformation from the 3D transformation of the environment
                 cFigure::Point o = canvasProjection->computeCanvasPoint(transmissionStart);
                 cFigure::Point x = canvasProjection->computeCanvasPoint(transmissionStart + Coord(1, 0, 0));
                 cFigure::Point y = canvasProjection->computeCanvasPoint(transmissionStart + Coord(0, 1, 0));
                 double t1 = o.x;
                 double t2 = o.y;
                 double a = x.x - t1;
                 double b = x.y - t2;
                 double c = y.x - t1;
                 double d = y.y - t2;
                 signalFigure->setTransform(cFigure::Transform(a, b, c, d, t1, t2));
                 signalFigure->setBounds(cFigure::Rectangle(-startRadius, -startRadius, startRadius * 2, startRadius * 2));
                 signalFigure->setInnerRx(endRadius);
                 signalFigure->setInnerRy(endRadius);
                 signalFigure->setWaveOffset(offset);
                 double currentSignalPropagationAnimationSpeed = std::isnan(signalPropagationAnimationSpeed) ? defaultSignalPropagationAnimationSpeed : signalPropagationAnimationSpeed;
                 signalFigure->setWaveOpacityFactor(std::min(1.0, currentSignalPropagationAnimationSpeed / getSimulation()->getEnvir()->getAnimationSpeed() / signalWaveFadingAnimationSpeedFactor));
                 signalFigure->refresh();
                 break;
             }
             case SIGNAL_SHAPE_SPHERE: {
                 // a sphere looks like a circle from any view angle
                 cFigure::Point center = canvasProjection->computeCanvasPoint(transmissionStart);
                 signalFigure->setBounds(cFigure::Rectangle(center.x - startRadius, center.y - startRadius, 2 * startRadius, 2 * startRadius));
                 signalFigure->setInnerRx(endRadius);
                 signalFigure->setInnerRy(endRadius);
                 break;
             }
             default:
                 throw cRuntimeError("Unimplemented signal shape");
         }
     }
 }

cFigure * inet::visualizer::MediumCanvasVisualizer::removeReceptionFigure ( const IRadio * radio )

protectedvirtual

Referenced by radioRemoved().

 {
     auto it = receptionFigures.find(radio);
     if (it == receptionFigures.end())
         return nullptr;
     else {
         receptionFigures.erase(it);
         return it->second;
     }
 }

cFigure * inet::visualizer::MediumCanvasVisualizer::removeSignalFigure ( const ITransmission * transmission )

protectedvirtual

Referenced by transmissionRemoved().

 {
     auto it = signalFigures.find(transmission);
     if (it == signalFigures.end())
         return nullptr;
     else {
         signalFigures.erase(it);
         return it->second;
     }
 }

cFigure * inet::visualizer::MediumCanvasVisualizer::removeTransmissionFigure ( const IRadio * radio )

protectedvirtual

Referenced by radioRemoved().

 {
     auto it = transmissionFigures.find(radio);
     if (it == transmissionFigures.end())
         return nullptr;
     else {
         transmissionFigures.erase(it);
         return it->second;
     }
 }

void inet::visualizer::MediumCanvasVisualizer::setAnimationSpeed ( )

protectedvirtual

Referenced by receptionEnded(), receptionStarted(), refreshDisplay(), transmissionAdded(), transmissionEnded(), transmissionRemoved(), and transmissionStarted().

 {
     SignalInProgress newSignalInProgress = SIP_NONE;
     double newSignalTransmissionAnimationSpeed = DBL_MAX;
     for (auto transmission : transmissions) {
         if (matchesTransmission(transmission)) {
             if (isSignalPropagationInProgress(transmission))
                 newSignalInProgress = SIP_PROPAGATION;
             if (isSignalTransmissionInProgress(transmission)) {
                 if (newSignalInProgress == SIP_NONE)
                     newSignalInProgress = SIP_TRANSMISSION;
                 // TODO: overwrite only...
                 if (std::isnan(signalTransmissionAnimationSpeed))
                     newSignalTransmissionAnimationSpeed = std::min(newSignalTransmissionAnimationSpeed, transmission->getDuration().dbl() / signalTransmissionAnimationTime);
             }
         }
     }
     if (newSignalTransmissionAnimationSpeed != DBL_MAX)
         defaultSignalTransmissionAnimationSpeed = newSignalTransmissionAnimationSpeed;
     double currentSignalPropagationAnimationSpeed = std::isnan(signalPropagationAnimationSpeed) ? defaultSignalPropagationAnimationSpeed : signalPropagationAnimationSpeed;
     double currentSignalTransmissionAnimationSpeed = std::isnan(signalTransmissionAnimationSpeed) ? defaultSignalTransmissionAnimationSpeed : signalTransmissionAnimationSpeed;
     AnimationPosition currentPosition;
     if (lastSignalInProgress == SIP_NONE) {
         if (newSignalInProgress == SIP_NONE) {
             if (animationSpeedInterpolator.getCurrentAnimationSpeed() == animationSpeedInterpolator.getTargetAnimationSpeed())
                 animationSpeedInterpolator.setAnimationSpeed(0);
         }
         else if (newSignalInProgress == SIP_PROPAGATION)
             animationSpeedInterpolator.setAnimationSpeed(currentSignalPropagationAnimationSpeed);
         else if (newSignalInProgress == SIP_TRANSMISSION)
             animationSpeedInterpolator.setAnimationSpeed(currentSignalTransmissionAnimationSpeed);
     }
     else if (lastSignalInProgress == SIP_PROPAGATION) {
         if (newSignalInProgress == SIP_NONE) {
             animationSpeedInterpolator.setCurrentAnimationSpeed(currentSignalPropagationAnimationSpeed);
             animationSpeedInterpolator.setTargetAnimationSpeed(AnimationPosition::REAL_TIME, currentPosition.getRealTime() + signalAnimationSpeedChangeTime, currentSignalTransmissionAnimationSpeed);
         }
         else if (newSignalInProgress == SIP_PROPAGATION)
             ; // void
         else if (newSignalInProgress == SIP_TRANSMISSION) {
             animationSpeedInterpolator.setCurrentAnimationSpeed(currentSignalPropagationAnimationSpeed);
             animationSpeedInterpolator.setTargetAnimationSpeed(AnimationPosition::REAL_TIME, currentPosition.getRealTime() + signalAnimationSpeedChangeTime, currentSignalTransmissionAnimationSpeed);
         }
     }
     else if (lastSignalInProgress == SIP_TRANSMISSION) {
         if (newSignalInProgress == SIP_NONE)
             animationSpeedInterpolator.setAnimationSpeed(0);
         else if (newSignalInProgress == SIP_PROPAGATION)
             animationSpeedInterpolator.setAnimationSpeed(currentSignalPropagationAnimationSpeed);
         else if (newSignalInProgress == SIP_TRANSMISSION)
             ; // void
     }
     lastSignalInProgress = newSignalInProgress;
     double animationSpeed = animationSpeedInterpolator.getCurrentAnimationSpeed();
     ASSERT(!std::isnan(animationSpeed));
     visualizerTargetModule->getCanvas()->setAnimationSpeed(animationSpeed, this);
 }

void inet::visualizer::MediumCanvasVisualizer::setReceptionFigure	(	const IRadio *	radio,
		cFigure *	figure
	)

protectedvirtual

Referenced by radioAdded().

 {
     receptionFigures[radio] = figure;
 }

void inet::visualizer::MediumCanvasVisualizer::setSignalFigure	(	const ITransmission *	transmission,
		cFigure *	figure
	)

protectedvirtual

Referenced by transmissionAdded().

 {
     signalFigures[transmission] = figure;
 }

void inet::visualizer::MediumCanvasVisualizer::setTransmissionFigure	(	const IRadio *	radio,
		cFigure *	figure
	)

protectedvirtual

Referenced by radioAdded().

 {
     transmissionFigures[radio] = figure;
 }

void inet::visualizer::MediumCanvasVisualizer::transmissionAdded ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (displaySignals && matchesTransmission(transmission)) {
         transmissions.push_back(transmission);
         cGroupFigure *signalFigure = createSignalFigure(transmission);
         signalLayer->addFigure(signalFigure);
         setSignalFigure(transmission, signalFigure);
         setAnimationSpeed();
     }
 }

void inet::visualizer::MediumCanvasVisualizer::transmissionEnded ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (matchesTransmission(transmission)) {
         if (displaySignals)
             setAnimationSpeed();
         if (displayTransmissions) {
             auto transmitter = transmission->getTransmitter();
             auto figure = getTransmissionFigure(transmitter);
             auto networkNode = getContainingNode(check_and_cast<const cModule *>(transmitter));
             auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
             networkNodeVisualization->setAnnotationVisible(figure, false);
         }
     }
 }

void inet::visualizer::MediumCanvasVisualizer::transmissionRemoved ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (displaySignals && matchesTransmission(transmission)) {
         transmissions.erase(std::remove(transmissions.begin(), transmissions.end(), transmission));
         cFigure *signalFigure = getSignalFigure(transmission);
         removeSignalFigure(transmission);
         if (signalFigure != nullptr)
             delete signalLayer->removeFigure(signalFigure);
         setAnimationSpeed();
     }
 }

void inet::visualizer::MediumCanvasVisualizer::transmissionStarted ( const ITransmission * transmission )

overrideprotectedvirtual

Implements inet::visualizer::MediumVisualizerBase.

 {
     Enter_Method_Silent();
     if (matchesTransmission(transmission)) {
         if (displaySignals)
             setAnimationSpeed();
         if (displayTransmissions) {
             auto transmitter = transmission->getTransmitter();
             auto figure = getTransmissionFigure(transmitter);
             auto networkNode = getContainingNode(check_and_cast<const cModule *>(transmitter));
             auto networkNodeVisualization = networkNodeVisualizer->getNetworkNodeVisualization(networkNode);
             networkNodeVisualization->setAnnotationVisible(figure, true);
             auto labelFigure = check_and_cast<LabeledIconFigure *>(figure)->getLabelFigure();
 #ifdef WITH_RADIO
             if (auto scalarTransmission = dynamic_cast<const ScalarTransmission *>(transmission)) {
                 char tmp[32];
                 sprintf(tmp, "%.4g dBW", inet::math::fraction2dB(W(scalarTransmission->getPower()).get()));
                 labelFigure->setText(tmp);
             }
             else
 #endif // WITH_RADIO
                 labelFigure->setText("");
         }
     }
 }