inet::visualizer::TreeCanvasVisualizerBase Class Reference

#include <TreeCanvasVisualizerBase.h>

Inheritance diagram for inet::visualizer::TreeCanvasVisualizerBase:

Classes
class	TreeCanvasVisualization

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	refreshDisplay () const override
virtual const TreeVisualization *	createTreeVisualization (const std::vector< std::vector< int >> &tree) const override
virtual void	addTreeVisualization (const TreeVisualization *treeVisualization) override
virtual void	removeTreeVisualization (const TreeVisualization *treeVisualization) override
Protected Member Functions inherited from inet::visualizer::TreeVisualizerBase
virtual void	handleParameterChange (const char *name) override
virtual void	preDelete (cComponent *root) override
virtual void	removeAllTreeVisualizations ()
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
double	zIndex = NaN
const CanvasProjection *	canvasProjection = nullptr
cGroupFigure *	treeGroup = nullptr
Protected Attributes inherited from inet::visualizer::TreeVisualizerBase
bool	displayTrees = false
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
LineManager *	lineManager = nullptr
std::map< int, int >	numTrees
	Maps nodes to the number of trees that go through it. More...
std::multimap< std::pair< int, int >, const TreeVisualization * >	treeVisualizations
	Maps source/destination modules to multiple trees between them. More...
Protected Attributes inherited from inet::visualizer::VisualizerBase
cModule *	visualizationTargetModule = nullptr
cModule *	visualizationSubjectModule = nullptr
const char *	tags = nullptr

Member Function Documentation

addTreeVisualization()

void inet::visualizer::TreeCanvasVisualizerBase::addTreeVisualization ( const TreeVisualization *  treeVisualization )

overrideprotectedvirtual

Reimplemented from inet::visualizer::TreeVisualizerBase.

{
    TreeVisualizerBase::addTreeVisualization(treeVisualization);
    auto treeCanvasVisualization = static_cast<const TreeCanvasVisualization *>(treeVisualization);
    for (auto& path : treeVisualization->paths)
        lineManager->addModulePath(&path);
    for (auto figure : treeCanvasVisualization->figures)
        treeGroup->addFigure(figure);
}

Referenced by inet::visualizer::FailureProtectionConfigurationCanvasVisualizer::initialize(), and inet::visualizer::StreamRedundancyConfigurationCanvasVisualizer::initialize().

createTreeVisualization()

const TreeVisualizerBase::TreeVisualization * inet::visualizer::TreeCanvasVisualizerBase::createTreeVisualization ( const std::vector< std::vector< int >> &  tree ) const

overrideprotectedvirtual

Implements inet::visualizer::TreeVisualizerBase.

Reimplemented in inet::visualizer::FailureProtectionConfigurationCanvasVisualizer, and inet::visualizer::StreamRedundancyConfigurationCanvasVisualizer.

{
    std::vector<LabeledPolylineFigure *> figures;
    for (int i = 0; i < tree.size(); i++) {
        auto figure = new LabeledPolylineFigure("tree");
        auto polylineFigure = figure->getPolylineFigure();
        polylineFigure->setSmooth(lineSmooth);
        polylineFigure->setLineWidth(lineWidth);
        polylineFigure->setLineStyle(lineStyle);
        polylineFigure->setEndArrowhead(cFigure::ARROW_BARBED);
        auto lineColor = lineColorSet.getColor(treeVisualizations.size());
        polylineFigure->setLineColor(lineColor);
        figures.push_back(figure);
    }
    return new TreeCanvasVisualization(tree, figures);
}

Referenced by inet::visualizer::FailureProtectionConfigurationCanvasVisualizer::createTreeVisualization(), and inet::visualizer::StreamRedundancyConfigurationCanvasVisualizer::createTreeVisualization().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::visualizer::TreeVisualizerBase.

Reimplemented in inet::visualizer::FailureProtectionConfigurationCanvasVisualizer, and inet::visualizer::StreamRedundancyConfigurationCanvasVisualizer.

{
    TreeVisualizerBase::initialize(stage);
    if (!hasGUI()) return;
    if (stage == INITSTAGE_LOCAL) {
        zIndex = par("zIndex");
        auto canvas = visualizationTargetModule->getCanvas();
        lineManager = LineManager::getCanvasLineManager(canvas);
        canvasProjection = CanvasProjection::getCanvasProjection(canvas);
        treeGroup = new cGroupFigure("trees");
        treeGroup->setZIndex(zIndex);
        canvas->addFigure(treeGroup);
    }
}

Referenced by inet::visualizer::FailureProtectionConfigurationCanvasVisualizer::initialize(), and inet::visualizer::StreamRedundancyConfigurationCanvasVisualizer::initialize().

refreshDisplay()

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

overrideprotectedvirtual

{
    TreeVisualizerBase::refreshDisplay();
    auto simulation = getSimulation();
    for (auto it : treeVisualizations) {
        auto treeVisualization = it.second;
        auto treeCanvasVisualization = static_cast<const TreeCanvasVisualization *>(treeVisualization);
        for (int i = 0; i < treeCanvasVisualization->paths.size(); i++) {
            auto& path = treeCanvasVisualization->paths[i];
            auto figure = treeCanvasVisualization->figures[i];
            auto moduleIds = path.moduleIds;
            std::vector<LineSegment> segments;
            for (size_t index = 1; index < moduleIds.size(); index++) {
                auto fromModuleId = moduleIds[index - 1];
                auto toModuleId = moduleIds[index];
                auto fromModule = simulation->getModule(fromModuleId);
                auto toModule = simulation->getModule(toModuleId);
                auto fromPosition = getContactPosition(fromModule, getPosition(toModule), lineContactMode, lineContactSpacing);
                auto toPosition = getContactPosition(toModule, getPosition(fromModule), lineContactMode, lineContactSpacing);
                auto shift = lineManager->getLineShift(fromModuleId, toModuleId, fromPosition, toPosition, lineShiftMode, path.shiftOffsets[index - 1]) * lineShift;
                segments.push_back(LineSegment(fromPosition + shift, toPosition + shift));
            }
            std::vector<cFigure::Point> points;
            for (size_t index = 0; index < segments.size(); index++) {
                if (index == 0)
                    points.push_back(canvasProjection->computeCanvasPoint(segments[index].getPoint1()));
                if (index > 0) {
                    auto& segment1 = segments[index - 1];
                    auto& segment2 = segments[index];
                    Coord intersection = intersectLines(segment1, segment2);
                    if (std::isfinite(intersection.x) && std::isfinite(intersection.y)) {
                        if (isPointOnSegment(segment1, intersection) && isPointOnSegment(segment2, intersection))
                            points.push_back(canvasProjection->computeCanvasPoint(intersection));
                        else {
                            double distance = segment1.getPoint2().distance(segment2.getPoint1());
                            double distance1 = intersection.distance(segment1.getPoint2());
                            double distance2 = intersection.distance(segment2.getPoint1());
                            if (distance1 + distance2 < 4 * distance)
                                points.push_back(canvasProjection->computeCanvasPoint(intersection));
                            else {
                                points.push_back(canvasProjection->computeCanvasPoint(segment1.getPoint2()));
                                points.push_back(canvasProjection->computeCanvasPoint(segment2.getPoint1()));
                            }
                        }
                    }
                    else {
                        points.push_back(canvasProjection->computeCanvasPoint(segment1.getPoint2()));
                        points.push_back(canvasProjection->computeCanvasPoint(segment2.getPoint1()));
                    }
                }
                if (index == segments.size() - 1)
                    points.push_back(canvasProjection->computeCanvasPoint(segments[index].getPoint2()));
            }
            figure->setPoints(points);
        }
    }
}

removeTreeVisualization()

void inet::visualizer::TreeCanvasVisualizerBase::removeTreeVisualization ( const TreeVisualization *  treeVisualization )

overrideprotectedvirtual

Reimplemented from inet::visualizer::TreeVisualizerBase.

{
    TreeVisualizerBase::removeTreeVisualization(treeVisualization);
    auto treeCanvasVisualization = static_cast<const TreeCanvasVisualization *>(treeVisualization);
    for (auto& path : treeVisualization->paths)
        lineManager->removeModulePath(&path);
    for (auto figure : treeCanvasVisualization->figures)
        treeGroup->removeFigure(figure);
}

Member Data Documentation

canvasProjection

const CanvasProjection* inet::visualizer::TreeCanvasVisualizerBase::canvasProjection = nullptr

protected

Referenced by initialize(), and refreshDisplay().

treeGroup

cGroupFigure* inet::visualizer::TreeCanvasVisualizerBase::treeGroup = nullptr

protected

Referenced by addTreeVisualization(), initialize(), and removeTreeVisualization().

zIndex

double inet::visualizer::TreeCanvasVisualizerBase::zIndex = NaN

protected

Referenced by initialize().

---

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

• TreeCanvasVisualizerBase.h
• TreeCanvasVisualizerBase.cc