PlotFigure Class Reference

#include <PlotFigure.h>

Inheritance diagram for PlotFigure:

Classes
struct	Tick

Public Member Functions
	PlotFigure (const char *name=nullptr)
virtual	~PlotFigure ()
virtual void	parse (cProperty *property) override
const char **	getAllowedPropertyKeys () const override
virtual void	refreshDisplay () override
virtual void	setValue (int series, simtime_t timestamp, double value) override
const Rectangle &	getBounds () const
void	setBounds (const Rectangle &rect)
const Color &	getBackgrouncColor () const
void	setBackgroundColor (const Color &color)
double	getValueTickSize () const
void	setValueTickSize (double size)
simtime_t	getTimeWindow () const
void	setTimeWindow (simtime_t timeWindow)
simtime_t	getTimeTickSize () const
void	setTimeTickSize (simtime_t size)
const Color &	getLineColor () const
void	setLineColor (const Color &color)
double	getMinValue () const
void	setMinValue (double value)
double	getMaxValue () const
void	setMaxValue (double value)
const char *	getLabel () const
void	setLabel (const char *text)
const int	getLabelOffset () const
void	setLabelOffset (int offset)
const Font &	getLabelFont () const
void	setLabelFont (const Font &font)
const Color &	getLabelColor () const
void	setLabelColor (const Color &color)
Public Member Functions inherited from inet::IIndicatorFigure
virtual	~IIndicatorFigure ()
virtual int	getNumSeries () const

Protected Member Functions
void	redrawValueTicks ()
void	redrawTimeTicks ()
void	addChildren ()
void	layout ()
void	refresh ()

Private Attributes
cPathFigure *	plotFigure
cTextFigure *	labelFigure
cRectangleFigure *	backgroundFigure
std::vector< Tick >	timeTicks
std::vector< Tick >	valueTicks
simtime_t	timeWindow = 10
double	valueTickSize = 2.5
simtime_t	timeTickSize = 3
int	labelOffset = 0
double	numberSizeFactor = 1
double	min = 0
double	max = 10
std::list< std::pair< simtime_t, double > >	values

Constructor & Destructor Documentation

PlotFigure::PlotFigure

(

const char *

name = nullptr

)

                                       : cGroupFigure(name)
{
    addChildren();
}

virtual PlotFigure::~PlotFigure ( )

inlinevirtual

{};

Member Function Documentation

void PlotFigure::addChildren ( )

protected

Referenced by PlotFigure().

{
    plotFigure = new cPathFigure("plot");
    labelFigure = new cTextFigure("label");
    backgroundFigure = new cRectangleFigure("bounds");

    backgroundFigure->setFilled(true);
    backgroundFigure->setFillColor(INIT_BACKGROUND_COLOR);
    plotFigure->setLineColor(INIT_PLOT_COLOR);
    labelFigure->setAnchor(ANCHOR_N);

    addFigure(backgroundFigure);
    addFigure(plotFigure);
    addFigure(labelFigure);
}

const char ** PlotFigure::getAllowedPropertyKeys ( ) const

override

{
    static const char *keys[32];
    if (!keys[0]) {
        const char *localKeys[] = {
            PKEY_VALUE_TICK_SIZE, PKEY_TIME_WINDOW, PKEY_TIME_TICK_SIZE,
            PKEY_LINE_COLOR, PKEY_MIN_VALUE, PKEY_MAX_VALUE, PKEY_BACKGROUND_COLOR,
            PKEY_LABEL, PKEY_LABEL_OFFSET, PKEY_LABEL_COLOR, PKEY_LABEL_FONT,
            PKEY_NUMBER_SIZE_FACTOR, PKEY_POS,
            PKEY_SIZE, PKEY_ANCHOR, PKEY_BOUNDS, nullptr
        };
        concatArrays(keys, cGroupFigure::getAllowedPropertyKeys(), localKeys);
    }
    return keys;
}

const cFigure::Color & PlotFigure::getBackgrouncColor

(

)

const

{
    return backgroundFigure->getFillColor();
}

const cFigure::Rectangle & PlotFigure::getBounds

(

)

const

Referenced by layout(), parse(), redrawTimeTicks(), redrawValueTicks(), and refresh().

{
    return backgroundFigure->getBounds();
}

const char * PlotFigure::getLabel

(

)

const

{
    return labelFigure->getText();
}

const cFigure::Color & PlotFigure::getLabelColor

(

)

const

{
    return labelFigure->getColor();
}

const cFigure::Font & PlotFigure::getLabelFont

(

)

const

{
    return labelFigure->getFont();
}

const int PlotFigure::getLabelOffset

(

)

const

{
    return labelOffset;
}

const cFigure::Color & PlotFigure::getLineColor

(

)

const

{
    return plotFigure->getLineColor();
}

double PlotFigure::getMaxValue

(

)

const

{
    return max;
}

double PlotFigure::getMinValue

(

)

const

{
    return min;
}

simtime_t PlotFigure::getTimeTickSize

(

)

const

{
    return timeTickSize;
}

simtime_t PlotFigure::getTimeWindow

(

)

const

{
    return timeWindow;
}

double PlotFigure::getValueTickSize

(

)

const

{
    return valueTickSize;
}

void PlotFigure::layout ( )

protected

Referenced by setBounds(), setLabelOffset(), setMaxValue(), setMinValue(), and setValueTickSize().

{
    redrawValueTicks();

    Rectangle b = getBounds();
    double fontSize = timeTicks.size() > 0 && timeTicks[0].number ? timeTicks[0].number->getFont().pointSize : 12;
    labelFigure->setPosition(Point(b.getCenter().x, b.y + b.height + fontSize * LABEL_Y_DISTANCE_FACTOR + labelOffset));
}

void PlotFigure::parse ( cProperty *  property )

overridevirtual

{
    cGroupFigure::parse(property);

    const char *s;
    if ((s = property->getValue(PKEY_NUMBER_SIZE_FACTOR)) != nullptr)
            numberSizeFactor = atof(s);

    setBounds(parseBounds(property, getBounds()));

    if ((s = property->getValue(PKEY_BACKGROUND_COLOR)) != nullptr)
        setBackgroundColor(parseColor(s));
    if ((s = property->getValue(PKEY_VALUE_TICK_SIZE)) != nullptr)
        setValueTickSize(atoi(s));
    if ((s = property->getValue(PKEY_TIME_WINDOW)) != nullptr)
        setTimeWindow(atoi(s));
    if ((s = property->getValue(PKEY_LINE_COLOR)) != nullptr)
        setLineColor(parseColor(s));
    if ((s = property->getValue(PKEY_MIN_VALUE)) != nullptr)
        setMinValue(atof(s));
    if ((s = property->getValue(PKEY_MAX_VALUE)) != nullptr)
        setMaxValue(atof(s));
    if ((s = property->getValue(PKEY_LABEL)) != nullptr)
        setLabel(s);
    if ((s = property->getValue(PKEY_LABEL_OFFSET)) != nullptr)
                setLabelOffset(atoi(s));
    if ((s = property->getValue(PKEY_LABEL_COLOR)) != nullptr)
        setLabelColor(parseColor(s));
    if ((s = property->getValue(PKEY_LABEL_FONT)) != nullptr)
        setLabelFont(parseFont(s));
    if ((s = property->getValue(PKEY_TIME_TICK_SIZE)) != nullptr)
        setTimeTickSize(atoi(s));
    else
        refresh();
}

void PlotFigure::redrawTimeTicks ( )

protected

Referenced by refresh().

{
    Rectangle bounds = getBounds();
    simtime_t minX = simTime() - timeWindow;

    double fraction = std::abs(fmod((minX / timeTickSize), 1));
    simtime_t shifting = timeTickSize * (minX < 0 ? fraction : 1 - fraction);
    // if fraction == 0 then shifting == timeTickSize therefore don't have to shift the time ticks
    if (shifting == timeTickSize)
        shifting = 0;

    int numTimeTicks = (timeWindow - shifting) / timeTickSize + 1;

    // Allocate ticks and numbers if needed
    if (numTimeTicks > timeTicks.size())
        while (numTimeTicks > timeTicks.size()) {
            cLineFigure *tick = new cLineFigure("timeTick");
            cLineFigure *dashLine = new cLineFigure("timeDashLine");
            cTextFigure *number = new cTextFigure("timeNumber");

            dashLine->setLineStyle(LINE_DASHED);

            number->setAnchor(ANCHOR_N);
            number->setFont(Font("", bounds.height * NUMBER_SIZE_PERCENT * numberSizeFactor));
            tick->insertBelow(plotFigure);
            dashLine->insertBelow(plotFigure);
            number->insertBelow(plotFigure);
            timeTicks.push_back(Tick(tick, dashLine, number));
        }
    else
        // Add or remove figures from canvas according to previous number of ticks
        for (int i = timeTicks.size() - 1; i >= numTimeTicks; --i) {
            delete removeFigure(timeTicks[i].number);
            delete removeFigure(timeTicks[i].dashLine);
            delete removeFigure(timeTicks[i].tick);
            timeTicks.pop_back();
        }

    for (int i = 0; i < timeTicks.size(); ++i) {
        double x = bounds.x + bounds.width * (i * timeTickSize + shifting) / timeWindow;
        double y = bounds.y + bounds.height;
        if (x > bounds.x && x < bounds.x + bounds.width) {
            timeTicks[i].tick->setVisible(true);
            timeTicks[i].tick->setStart(Point(x, y));
            timeTicks[i].tick->setEnd(Point(x, y - TICK_LENGTH));

            timeTicks[i].dashLine->setVisible(true);
            timeTicks[i].dashLine->setStart(Point(x, y - TICK_LENGTH));
            timeTicks[i].dashLine->setEnd(Point(x, bounds.y));
        }
        else {
            timeTicks[i].tick->setVisible(false);
            timeTicks[i].dashLine->setVisible(false);
        }

        char buf[32];
        simtime_t number = minX.dbl() + i * timeTickSize + shifting;

        sprintf(buf, "%g", number.dbl());
        timeTicks[i].number->setText(buf);
        timeTicks[i].number->setPosition(Point(x, y + bounds.height * NUMBER_DISTANCE_FROM_TICK));
    }
}

void PlotFigure::redrawValueTicks ( )

protected

Referenced by layout().

{
    Rectangle bounds = getBounds();
    int numTicks = std::abs(max - min) / valueTickSize + 1;

    int fontSize = bounds.height * NUMBER_SIZE_PERCENT * numberSizeFactor;

    double valueTickYposAdjust[2] = { 0, 0 };

    if(valueTicks.size() == 1)
    {
        valueTickYposAdjust[0] = - (fontSize / 2);
        valueTickYposAdjust[1] = fontSize / 2;
    }

    // Allocate ticks and numbers if needed
    if (numTicks > valueTicks.size())
        while (numTicks > valueTicks.size()) {
            cLineFigure *tick = new cLineFigure("valueTick");
            cLineFigure *dashLine = new cLineFigure("valueDashLine");
            cTextFigure *number = new cTextFigure("valueNumber");

            dashLine->setLineStyle(LINE_DASHED);

            number->setAnchor(ANCHOR_W);
            number->setFont(Font("", bounds.height * NUMBER_SIZE_PERCENT * numberSizeFactor));
            tick->insertBelow(plotFigure);
            dashLine->insertBelow(plotFigure);
            number->insertBelow(plotFigure);
            valueTicks.push_back(Tick(tick, dashLine, number));
        }
    else
        // Add or remove figures from canvas according to previous number of ticks
        for (int i = valueTicks.size() - 1; i >= numTicks; --i) {
            delete removeFigure(valueTicks[i].number);
            delete removeFigure(valueTicks[i].dashLine);
            delete removeFigure(valueTicks[i].tick);
            valueTicks.pop_back();
        }

    for (int i = 0; i < valueTicks.size(); ++i) {
        double x = bounds.x + bounds.width;
        double y = bounds.y + bounds.height - bounds.height * (i * valueTickSize) / std::abs(max - min);
        if (y > bounds.y && y < bounds.y + bounds.height) {
            valueTicks[i].tick->setVisible(true);
            valueTicks[i].tick->setStart(Point(x, y));
            valueTicks[i].tick->setEnd(Point(x - TICK_LENGTH, y));

            valueTicks[i].dashLine->setVisible(true);
            valueTicks[i].dashLine->setStart(Point(x - TICK_LENGTH, y));
            valueTicks[i].dashLine->setEnd(Point(bounds.x, y));
        }
        else {
            valueTicks[i].tick->setVisible(false);
            valueTicks[i].dashLine->setVisible(false);
        }

        char buf[32];
        sprintf(buf, "%g", min + i * valueTickSize);
        valueTicks[i].number->setText(buf);
        valueTicks[i].number->setPosition(Point(x + bounds.height * NUMBER_DISTANCE_FROM_TICK, y + valueTickYposAdjust[i % 2]));
    }
}

void PlotFigure::refresh ( )

protected

Referenced by parse(), refreshDisplay(), setTimeTickSize(), setTimeWindow(), and setValue().

{
    // timeTicks + timeNumbers
    redrawTimeTicks();

    // plot
    simtime_t minX = simTime() - timeWindow;
    simtime_t maxX = simTime();

    plotFigure->clearPath();

    if (values.size() < 2)
        return;
    if (minX > values.front().first) {
        values.clear();
        return;
    }

    auto r = getBounds();
    auto it = values.begin();
    double startX = r.x + r.width - (maxX - it->first).dbl() / timeWindow * r.width;
    double startY = r.y + (max - it->second) / std::abs(max - min) * r.height;
    plotFigure->addMoveTo(startX, startY);

    ++it;
    do {
        double endX = r.x + r.width - (maxX - it->first).dbl() / timeWindow * r.width;
        double endY = r.y + (max - it->second) / std::abs(max - min) * r.height;

        double originalStartX = startX;
        double originalStartY = startY;
        double originalEndX = endX;
        double originalEndY = endY;
        if (InstrumentUtil::CohenSutherlandLineClip(startX, startY, endX, endY, r.x, r.x + r.width, r.y, r.y + r.height)) {
            if (originalStartX != startX || originalStartY != startY)
                plotFigure->addMoveTo(startX, startY);

            plotFigure->addLineTo(endX, endY);
        }

        if (minX > it->first)
            break;

        startX = originalEndX;
        startY = originalEndY;
        ++it;
    } while (it != values.end());

    // Delete old elements
    if (it != values.end())
        values.erase(++it, values.end());
}

void PlotFigure::refreshDisplay ( )

overridevirtual

Reimplemented from inet::IIndicatorFigure.

{
    refresh();
}

void PlotFigure::setBackgroundColor

(

const Color &

color

)

Referenced by parse().

{
    backgroundFigure->setFillColor(color);
}

void PlotFigure::setBounds

(

const Rectangle &

rect

)

Referenced by parse().

{
    if (backgroundFigure->getBounds() == rect)
        return;

    backgroundFigure->setBounds(rect);
    layout();
}

void PlotFigure::setLabel

(

const char *

text

)

Referenced by parse().

{
    labelFigure->setText(text);
}

void PlotFigure::setLabelColor

(

const Color &

color

)

Referenced by parse().

{
    labelFigure->setColor(color);
}

void PlotFigure::setLabelFont

(

const Font &

font

)

Referenced by parse().

{
    labelFigure->setFont(font);
}

void PlotFigure::setLabelOffset

(

int

offset

)

Referenced by parse().

{
    if(labelOffset != offset)   {
        labelOffset = offset;
        layout();
    }
}

void PlotFigure::setLineColor

(

const Color &

color

)

Referenced by parse().

{
    plotFigure->setLineColor(color);
}

void PlotFigure::setMaxValue

(

double

value

)

Referenced by parse().

{
    if (max == value)
        return;

    max = value;
    layout();
}

void PlotFigure::setMinValue

(

double

value

)

Referenced by parse().

{
    if (min == value)
        return;

    min = value;
    layout();
}

void PlotFigure::setTimeTickSize

(

simtime_t

size

)

Referenced by parse().

{
    if (timeTickSize == size)
        return;

    timeTickSize = size;
    refresh();
}

void PlotFigure::setTimeWindow

(

simtime_t

timeWindow

)

Referenced by parse().

{
    if (this->timeWindow == timeWindow)
        return;

    this->timeWindow = timeWindow;
    refresh();
}

void PlotFigure::setValue ( int  series, simtime_t  timestamp, double  value  )

overridevirtual

Implements inet::IIndicatorFigure.

{
    ASSERT(series == 0);

    values.push_front(std::pair<simtime_t, double>(timestamp, value));
    refresh();
}

void PlotFigure::setValueTickSize

(

double

size

)

Referenced by parse().

{
    if (valueTickSize == size)
        return;

    valueTickSize = size;
    layout();
}

Member Data Documentation

cRectangleFigure* PlotFigure::backgroundFigure

private

Referenced by addChildren(), getBackgrouncColor(), getBounds(), setBackgroundColor(), and setBounds().

cTextFigure* PlotFigure::labelFigure

private

Referenced by addChildren(), getLabel(), getLabelColor(), getLabelFont(), layout(), setLabel(), setLabelColor(), and setLabelFont().

int PlotFigure::labelOffset = 0

private

Referenced by getLabelOffset(), layout(), and setLabelOffset().

double PlotFigure::max = 10

private

Referenced by getMaxValue(), redrawValueTicks(), refresh(), and setMaxValue().

double PlotFigure::min = 0

private

Referenced by getMinValue(), redrawValueTicks(), refresh(), and setMinValue().

double PlotFigure::numberSizeFactor = 1

private

Referenced by parse(), redrawTimeTicks(), and redrawValueTicks().

cPathFigure* PlotFigure::plotFigure

private

Referenced by addChildren(), getLineColor(), redrawTimeTicks(), redrawValueTicks(), refresh(), and setLineColor().

std::vector<Tick> PlotFigure::timeTicks

private

Referenced by layout(), and redrawTimeTicks().

simtime_t PlotFigure::timeTickSize = 3

private

Referenced by getTimeTickSize(), redrawTimeTicks(), and setTimeTickSize().

simtime_t PlotFigure::timeWindow = 10

private

Referenced by getTimeWindow(), redrawTimeTicks(), refresh(), and setTimeWindow().

std::list<std::pair<simtime_t, double> > PlotFigure::values

private

Referenced by refresh(), and setValue().

std::vector<Tick> PlotFigure::valueTicks

private

Referenced by redrawValueTicks().

double PlotFigure::valueTickSize = 2.5

private

Referenced by getValueTickSize(), redrawValueTicks(), and setValueTickSize().

---

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

• PlotFigure.h
• PlotFigure.cc