inet::visualizer::NetworkNodeCanvasVisualization Class Reference

#include <NetworkNodeCanvasVisualization.h>

Inheritance diagram for inet::visualizer::NetworkNodeCanvasVisualization:

Classes
class	Annotation

Public Member Functions
	NetworkNodeCanvasVisualization (cModule *networkNode, double annotationSpacing, double placementPenalty)
virtual void	refreshDisplay () override
virtual int	getNumAnnotations () const
virtual void	addAnnotation (cFigure *figure, cFigure::Point size, Placement placement=PLACEMENT_ANY, double placementPriority=0)
virtual void	removeAnnotation (cFigure *figure)
virtual void	removeAnnotation (int index)
virtual void	setAnnotationSize (cFigure *figure, cFigure::Point size)
virtual void	setAnnotationVisible (cFigure *figure, bool visible)
Public Member Functions inherited from inet::visualizer::NetworkNodeVisualizerBase::NetworkNodeVisualization
	NetworkNodeVisualization (const cModule *networkNode)
virtual	~NetworkNodeVisualization ()

Protected Member Functions
virtual void	layout ()

Protected Attributes
double	annotationSpacing = NaN
double	placementPenalty = NaN
bool	isLayoutInvalid = false
cFigure::Rectangle	submoduleBounds
std::vector< Annotation >	annotations
cPanelFigure *	annotationFigure = nullptr

Additional Inherited Members
Public Attributes inherited from inet::visualizer::NetworkNodeVisualizerBase::NetworkNodeVisualization
const cModule *	networkNode

Constructor & Destructor Documentation

NetworkNodeCanvasVisualization()

inet::visualizer::NetworkNodeCanvasVisualization::NetworkNodeCanvasVisualization	(	cModule *	networkNode,
		double	annotationSpacing,
		double	placementPenalty
	)

                                                                                                                                      :
    NetworkNodeVisualizerBase::NetworkNodeVisualization(networkNode),
    cGroupFigure(networkNode->getFullName()),
    annotationSpacing(annotationSpacing),
    placementPenalty(placementPenalty)
{
    annotationFigure = new cPanelFigure("annotation");
    addFigure(annotationFigure);
    submoduleBounds = getEnvir()->getSubmoduleBounds(networkNode);
    submoduleBounds.height += 32; // KLUDGE extend bounds for submodule name label
    submoduleBounds.x = -submoduleBounds.width / 2;
    submoduleBounds.y = -submoduleBounds.height / 2;
    if (networkNode->hasPar("canvasImage") && strlen(networkNode->par("canvasImage")) != 0) {
        auto imageFigure = new cImageFigure("node");
        imageFigure->setTooltip("This image represents a network node");
        imageFigure->setTooltip("");
        imageFigure->setAssociatedObject(networkNode);
        imageFigure->setImageName(networkNode->par("canvasImage"));
        if (networkNode->hasPar("canvasImageColor") && strlen(networkNode->par("canvasImageColor")) != 0)
            imageFigure->setTintColor(cFigure::parseColor(networkNode->par("canvasImageColor")));
        addFigure(imageFigure);
    }
}

Member Function Documentation

addAnnotation()

void inet::visualizer::NetworkNodeCanvasVisualization::addAnnotation ( cFigure *  figure, cFigure::Point  size, Placement  placement = PLACEMENT_ANY, double  placementPriority = 0  )

virtual

{
    annotations.push_back(Annotation(figure, size, placementHint, placementPriority));
    annotationFigure->addFigure(figure);
    isLayoutInvalid = true;
}

Referenced by inet::visualizer::Ieee80211CanvasVisualizer::addIeee80211Visualization(), and inet::visualizer::RadioCanvasVisualizer::addRadioVisualization().

getNumAnnotations()

virtual int inet::visualizer::NetworkNodeCanvasVisualization::getNumAnnotations ( ) const

inlinevirtual

{ return annotations.size(); }

layout()

void inet::visualizer::NetworkNodeCanvasVisualization::layout ( )

protectedvirtual

{
    std::vector<cFigure::Rectangle> rcs; // rectangles of annotations already positioned
    std::vector<cFigure::Point> pts; // candidate points where annotations may be positioned
    cFigure::Rectangle extendendSubmoduleBounds = submoduleBounds;
    extendendSubmoduleBounds.x -= annotationSpacing / 2;
    extendendSubmoduleBounds.y -= annotationSpacing / 2;
    extendendSubmoduleBounds.width += annotationSpacing;
    extendendSubmoduleBounds.height += annotationSpacing;
    rcs.push_back(extendendSubmoduleBounds);
    pts.push_back(getTopLeft(extendendSubmoduleBounds));
    pts.push_back(getTopCenter(extendendSubmoduleBounds));
    pts.push_back(getTopRight(extendendSubmoduleBounds));
    pts.push_back(getCenterLeft(extendendSubmoduleBounds));
    pts.push_back(getCenterCenter(extendendSubmoduleBounds));
    pts.push_back(getCenterRight(extendendSubmoduleBounds));
    pts.push_back(getBottomLeft(extendendSubmoduleBounds));
    pts.push_back(getBottomCenter(extendendSubmoduleBounds));
    pts.push_back(getBottomRight(extendendSubmoduleBounds));
 
    std::sort(annotations.begin(), annotations.end(), Annotation::comparePlacementPriority);
 
    // delete all annotation positions
    for (auto it = annotations.begin(); it != annotations.end(); it++) {
        auto& annotation = *it;
        annotation.bounds.x = NaN;
        annotation.bounds.y = NaN;
    }
 
    for (auto it = annotations.begin(); it != annotations.end(); it++) {
        auto& annotation = *it;
        if (!annotation.figure->isVisible())
            continue;
        cFigure::Point rs = cFigure::Point(annotation.bounds.width + annotationSpacing, annotation.bounds.height + annotationSpacing);
 
        // find the best minimizing the distance cost function
        double bestDistance = std::numeric_limits<double>::infinity();
        cFigure::Rectangle bestRc;
 
        // for all candidate points
        for (auto pt : pts) {
            // align annotation to candidate points with its various points
            for (int k = 0; k < 9; k++) {
                cFigure::Rectangle candidateRc;
                switch (k) {
                    case 0:
                        // candidate point is top left
                        candidateRc = createRectangle(pt - cFigure::Point(0, 0), rs);
                        break;
                    case 1:
                        // candidate point is top center
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x / 2, 0), rs);
                        break;
                    case 2:
                        // candidate point is top right
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x, 0), rs);
                        break;
                    case 3:
                        // candidate point is center left
                        candidateRc = createRectangle(pt - cFigure::Point(0, rs.y / 2), rs);
                        break;
                    case 4:
                        // candidate point is center center
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x / 2, rs.y / 2), rs);
                        break;
                    case 5:
                        // candidate point is center right
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x, rs.y / 2), rs);
                        break;
                    case 6:
                        // candidate point is bottom left
                        candidateRc = createRectangle(pt - cFigure::Point(0, rs.y), rs);
                        break;
                    case 7:
                        // candidate point is bottom center
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x / 2, rs.y), rs);
                        break;
                    case 8:
                        // candidate point is bottom right
                        candidateRc = createRectangle(pt - cFigure::Point(rs.x, rs.y), rs);
                        break;
                    default:
                        throw cRuntimeError("Invalid case");
                }
 
                double distance = 0;
                if (annotation.placementHint != PLACEMENT_CENTER_CENTER) {
                    distance += getClosestPlacementDistance(submoduleBounds, annotation.placementHint, getTopLeft(candidateRc)) * placementPenalty;
                    distance += getClosestPlacementDistance(submoduleBounds, annotation.placementHint, getTopRight(candidateRc)) * placementPenalty;
                    distance += getClosestPlacementDistance(submoduleBounds, annotation.placementHint, getBottomLeft(candidateRc)) * placementPenalty;
                    distance += getClosestPlacementDistance(submoduleBounds, annotation.placementHint, getBottomRight(candidateRc)) * placementPenalty;
 
                    // find an already positioned annotation which would intersect the candidate rectangle
                    bool intersects = false;
                    for (const auto& rc : rcs) {
                        if (intersectsRectangle(candidateRc, rc)) {
                            intersects = true;
                            break;
                        }
                    }
                    if (intersects)
                        continue;
                }
 
                // if better than the current best
                distance += getCenterCenter(submoduleBounds).distanceTo(getCenterCenter(candidateRc));
                if (distance < bestDistance) {
                    bestRc = candidateRc;
                    bestDistance = distance;
                    if (distance == 0)
                        goto found;
                }
            }
        }
 
      found:
        // store position and rectangle
        annotation.bounds.x = bestRc.x + annotationSpacing / 2;
        annotation.bounds.y = bestRc.y + annotationSpacing / 2;
        annotation.figure->setTransform(cFigure::Transform().translate(annotation.bounds.x, annotation.bounds.y));
 
        // delete candidate points covered by best rc
        for (auto j = pts.begin(); j != pts.end();) {
            if (containsPoint(bestRc, *j))
                j = pts.erase(j);
            else
                ++j;
        }
 
        // push new candidates
        pushUnlessContains(pts, rcs, getTopLeft(bestRc));
        pushUnlessContains(pts, rcs, getTopCenter(bestRc));
        pushUnlessContains(pts, rcs, getTopRight(bestRc));
        pushUnlessContains(pts, rcs, getCenterLeft(bestRc));
        pushUnlessContains(pts, rcs, getCenterCenter(bestRc));
        pushUnlessContains(pts, rcs, getCenterRight(bestRc));
        pushUnlessContains(pts, rcs, getBottomLeft(bestRc));
        pushUnlessContains(pts, rcs, getBottomCenter(bestRc));
        pushUnlessContains(pts, rcs, getBottomRight(bestRc));
 
        rcs.push_back(bestRc);
    }
}

Referenced by refreshDisplay().

refreshDisplay()

void inet::visualizer::NetworkNodeCanvasVisualization::refreshDisplay ( )

overridevirtual

{
    if (isLayoutInvalid) {
        layout();
        isLayoutInvalid = false;
    }
}

removeAnnotation() [1/2]

void inet::visualizer::NetworkNodeCanvasVisualization::removeAnnotation ( cFigure *  figure )

virtual

{
    for (auto it = annotations.begin(); it != annotations.end(); it++) {
        auto& annotation = *it;
        if (annotation.figure == figure) {
            annotations.erase(it);
            break;
        }
    }
    annotationFigure->removeFigure(figure);
    isLayoutInvalid = true;
}

Referenced by inet::visualizer::Ieee80211CanvasVisualizer::removeIeee80211Visualization(), inet::visualizer::RadioCanvasVisualizer::removeRadioVisualization(), and inet::visualizer::StatisticCanvasVisualizer::removeStatisticVisualization().

removeAnnotation() [2/2]

void inet::visualizer::NetworkNodeCanvasVisualization::removeAnnotation ( int  index )

virtual

{
    auto it = annotations.begin() + index;
    auto figure = (*it).figure;
    annotations.erase(it);
    annotationFigure->removeFigure(figure);
    isLayoutInvalid = true;
}

setAnnotationSize()

void inet::visualizer::NetworkNodeCanvasVisualization::setAnnotationSize ( cFigure *  figure, cFigure::Point  size  )

virtual

{
    for (auto it = annotations.begin(); it != annotations.end(); it++) {
        auto& annotation = *it;
        if (annotation.figure == figure) {
            annotation.bounds.width = size.x;
            annotation.bounds.height = size.y;
            break;
        }
    }
    isLayoutInvalid = true;
}

setAnnotationVisible()

void inet::visualizer::NetworkNodeCanvasVisualization::setAnnotationVisible ( cFigure *  figure, bool  visible  )

virtual

{
    figure->setVisible(visible);
    isLayoutInvalid = true;
}

Member Data Documentation

annotationFigure

cPanelFigure* inet::visualizer::NetworkNodeCanvasVisualization::annotationFigure = nullptr

protected

Referenced by addAnnotation(), NetworkNodeCanvasVisualization(), and removeAnnotation().

annotations

std::vector<Annotation> inet::visualizer::NetworkNodeCanvasVisualization::annotations

protected

Referenced by addAnnotation(), layout(), removeAnnotation(), and setAnnotationSize().

annotationSpacing

double inet::visualizer::NetworkNodeCanvasVisualization::annotationSpacing = NaN

protected

Referenced by layout().

isLayoutInvalid

bool inet::visualizer::NetworkNodeCanvasVisualization::isLayoutInvalid = false

protected

Referenced by addAnnotation(), refreshDisplay(), removeAnnotation(), setAnnotationSize(), and setAnnotationVisible().

placementPenalty

double inet::visualizer::NetworkNodeCanvasVisualization::placementPenalty = NaN

protected

Referenced by layout().

submoduleBounds

cFigure::Rectangle inet::visualizer::NetworkNodeCanvasVisualization::submoduleBounds

protected

Referenced by layout(), and NetworkNodeCanvasVisualization().

---

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

• NetworkNodeCanvasVisualization.h
• NetworkNodeCanvasVisualization.cc