inet::visualizer::SceneCanvasVisualizer Class Reference

#include <SceneCanvasVisualizer.h>

Inheritance diagram for inet::visualizer::SceneCanvasVisualizer:

Protected Member Functions
virtual void	initialize (int stage) override
virtual void	initializeAxis (double axisLength)
virtual void	handleParameterChange (const char *name) override
virtual EulerAngles	computeViewAngle (const char *viewAngle)
virtual cFigure::Point	parse2D (const char *text)
virtual void	displayDescription (const char *descriptionFigurePath)
Protected Member Functions inherited from inet::visualizer::SceneVisualizerBase
virtual Box	getPlaygroundBounds ()
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
CanvasProjection	canvasProjection
cGroupFigure *	axisLayer = nullptr
Protected Attributes inherited from inet::visualizer::VisualizerBase
cModule *	visualizerTargetModule = nullptr
const char *	tags = nullptr

Member Function Documentation

EulerAngles inet::visualizer::SceneCanvasVisualizer::computeViewAngle ( const char *  viewAngle )

protectedvirtual

Referenced by handleParameterChange(), and initialize().

{
    double x, y, z;
    if (!strcmp(viewAngle, "x"))
    {
        x = 0;
        y = M_PI / 2;
        z = M_PI / -2;
    }
    else if (!strcmp(viewAngle, "y"))
    {
        x = M_PI / 2;
        y = 0;
        z = 0;
    }
    else if (!strcmp(viewAngle, "z"))
    {
        x = y = z = 0;
    }
    else if (!strncmp(viewAngle, "isometric", 9))
    {
        int v;
        int l = strlen(viewAngle);
        switch (l) {
            case 9: v = 0; break;
            case 10: v = viewAngle[9] - '0'; break;
            case 11: v = (viewAngle[9] - '0') * 10 + viewAngle[10] - '0'; break;
            default: throw cRuntimeError("Invalid isometric viewAngle parameter");
        }
        // 1st axis can point on the 2d plane in 6 directions
        // 2nd axis can point on the 2d plane in 4 directions (the opposite direction is forbidden)
        // 3rd axis can point on the 2d plane in 2 directions
        // this results in 6 * 4 * 2 = 48 different configurations
        x = math::deg2rad(45 + v % 4 * 90);
        y = math::deg2rad(v / 24 % 2 ? 35.27 : -35.27);
        z = math::deg2rad(30 + v / 4 % 6 * 60);
    }
    else if (sscanf(viewAngle, "%lf %lf %lf", &x, &y, &z) == 3)
    {
        x = math::deg2rad(x);
        y = math::deg2rad(y);
        z = math::deg2rad(z);
    }
    else
        throw cRuntimeError("The viewAngle parameter must be a predefined string or a triplet representing three degrees");
    return EulerAngles(x, y, z);
}

void inet::visualizer::SceneCanvasVisualizer::displayDescription ( const char *  descriptionFigurePath )

protectedvirtual

Referenced by initialize().

{
    cFigure* descriptionFigure = visualizerTargetModule->getCanvas()->getFigureByPath(descriptionFigurePath);
    if (!descriptionFigure)
        throw cRuntimeError("Figure \"%s\" not found", descriptionFigurePath);
    auto descriptionTextFigure = check_and_cast<cAbstractTextFigure*>(descriptionFigure);

    auto config = getEnvir()->getConfigEx();
    const char *activeConfig = config->getActiveConfigName();
    std::string description = std::string(activeConfig) + ": " + config->getConfigDescription(activeConfig);
    descriptionTextFigure->setText(description.c_str());
}

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

overrideprotectedvirtual

{
    if (name && !strcmp(name, "viewAngle")) {
        canvasProjection.setRotation(Rotation(computeViewAngle(par("viewAngle"))));
        // TODO: update all visualizers
    }
    else if (name && !strcmp(name, "viewScale")) {
        canvasProjection.setScale(parse2D(par("viewScale")));
        // TODO: update all visualizers
    }
    else if (name && !strcmp(name, "viewTranslation")) {
        canvasProjection.setTranslation(parse2D(par("viewTranslation")));
        // TODO: update all visualizers
    }
}

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

overrideprotectedvirtual

Reimplemented from inet::visualizer::SceneVisualizerBase.

{
    SceneVisualizerBase::initialize(stage);
    if (!hasGUI()) return;
    if (stage == INITSTAGE_LOCAL) {
        zIndex = par("zIndex");
        cCanvas *canvas = visualizerTargetModule->getCanvas();
        canvasProjection.setRotation(Rotation(computeViewAngle(par("viewAngle"))));
        canvasProjection.setScale(parse2D(par("viewScale")));
        canvasProjection.setTranslation(parse2D(par("viewTranslation")));
        CanvasProjection::setCanvasProjection(canvas, &canvasProjection);
        axisLayer = new cGroupFigure("axisLayer");
        axisLayer->setZIndex(zIndex);
        axisLayer->insertBelow(canvas->getSubmodulesLayer());
        double axisLength = par("axisLength");
        if (!std::isnan(axisLength))
            initializeAxis(axisLength);
        std::string descriptionFigurePath = par("descriptionFigure");
        if (!descriptionFigurePath.empty())
            displayDescription(descriptionFigurePath.c_str());
    }
}

void inet::visualizer::SceneCanvasVisualizer::initializeAxis ( double  axisLength )

protectedvirtual

Referenced by initialize().

{
    cLineFigure *xAxis = new cLineFigure("xAxis");
    cLineFigure *yAxis = new cLineFigure("yAxis");
    cLineFigure *zAxis = new cLineFigure("zAxis");
    auto axisTags = std::string("axis ") + tags;
    xAxis->setTags(axisTags.c_str());
    yAxis->setTags(axisTags.c_str());
    zAxis->setTags(axisTags.c_str());
    xAxis->setTooltip("This arrow represents the X axis of the playground");
    yAxis->setTooltip("This arrow represents the Y axis of the playground");
    zAxis->setTooltip("This arrow represents the Z axis of the playground");
    xAxis->setLineWidth(1);
    yAxis->setLineWidth(1);
    zAxis->setLineWidth(1);
    xAxis->setEndArrowhead(cFigure::ARROW_BARBED);
    yAxis->setEndArrowhead(cFigure::ARROW_BARBED);
    zAxis->setEndArrowhead(cFigure::ARROW_BARBED);
    xAxis->setZoomLineWidth(false);
    yAxis->setZoomLineWidth(false);
    zAxis->setZoomLineWidth(false);
    xAxis->setStart(canvasProjection.computeCanvasPoint(Coord::ZERO));
    yAxis->setStart(canvasProjection.computeCanvasPoint(Coord::ZERO));
    zAxis->setStart(canvasProjection.computeCanvasPoint(Coord::ZERO));
    xAxis->setEnd(canvasProjection.computeCanvasPoint(Coord(axisLength, 0, 0)));
    yAxis->setEnd(canvasProjection.computeCanvasPoint(Coord(0, axisLength, 0)));
    zAxis->setEnd(canvasProjection.computeCanvasPoint(Coord(0, 0, axisLength)));
    axisLayer->addFigure(xAxis);
    axisLayer->addFigure(yAxis);
    axisLayer->addFigure(zAxis);
    cLabelFigure *xLabel = new cLabelFigure("xAxisLabel");
    cLabelFigure *yLabel = new cLabelFigure("yAxisLabel");
    cLabelFigure *zLabel = new cLabelFigure("zAxisLabel");
    auto axisLabelTags = std::string("axis label ") + tags;
    xLabel->setTags(axisLabelTags.c_str());
    yLabel->setTags(axisLabelTags.c_str());
    zLabel->setTags(axisLabelTags.c_str());
    xLabel->setText("X");
    yLabel->setText("Y");
    zLabel->setText("Z");
    xLabel->setPosition(canvasProjection.computeCanvasPoint(Coord(axisLength, 0, 0)));
    yLabel->setPosition(canvasProjection.computeCanvasPoint(Coord(0, axisLength, 0)));
    zLabel->setPosition(canvasProjection.computeCanvasPoint(Coord(0, 0, axisLength)));
    axisLayer->addFigure(xLabel);
    axisLayer->addFigure(yLabel);
    axisLayer->addFigure(zLabel);
}

cFigure::Point inet::visualizer::SceneCanvasVisualizer::parse2D ( const char *  text )

protectedvirtual

Referenced by handleParameterChange(), and initialize().

{
    double x, y;
    if (sscanf(text, "%lf %lf", &x, &y) != 2)
        throw cRuntimeError("The parameter must be a pair of doubles: %s", text);
    return cFigure::Point(x, y);
}

Member Data Documentation

cGroupFigure* inet::visualizer::SceneCanvasVisualizer::axisLayer = nullptr

protected

Referenced by initialize(), and initializeAxis().

CanvasProjection inet::visualizer::SceneCanvasVisualizer::canvasProjection

protected

Referenced by handleParameterChange(), initialize(), and initializeAxis().

double inet::visualizer::SceneCanvasVisualizer::zIndex = NaN

protected

Referenced by initialize().

---

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

• SceneCanvasVisualizer.h
• SceneCanvasVisualizer.cc