inet::SignalFigure Class Reference

#include <SignalFigure.h>

Inheritance diagram for inet::SignalFigure:

Public Member Functions
	SignalFigure (const char *name=nullptr)
void	setColor (const cFigure::Color &color)
void	setOpacity (double opacity)
void	setBounds (const cFigure::Rectangle &bounds)
void	setInnerRx (double innerRx)
void	setInnerRy (double innerRy)
int	getRingCount () const
void	setRingCount (int count)
double	getRingSize () const
void	setRingSize (double ringSize)
double	getFadingDistance () const
void	setFadingDistance (double fadingDistance)
double	getFadingFactor () const
void	setFadingFactor (double fadingFactor)
int	getWaveCount () const
void	setWaveCount (int count)
double	getWaveLength () const
void	setWaveLength (double waveLength)
double	getWaveWidth () const
void	setWaveWidth (double waveWidth)
double	getWaveOffset () const
void	setWaveOffset (double waveOffset)
double	getWaveOpacityFactor () const
void	setWaveOpacityFactor (double waveOpacityFactor)
void	refresh ()

Protected Attributes
double	opacity = NaN
double	ringSize = NaN
double	fadingDistance = NaN
double	fadingFactor = NaN
double	waveLength = NaN
double	waveWidth = NaN
double	waveOffset = NaN
double	waveOpacityFactor = NaN
std::vector< cRingFigure * >	rings
std::vector< cOvalFigure * >	waves
Rectangle	bounds
double	innerRx = NaN
double	innerRy = NaN

Constructor & Destructor Documentation

SignalFigure()

inet::SignalFigure::SignalFigure

(

const char *

name = nullptr

)

                                           :
    cGroupFigure(name)
{
}

Member Function Documentation

getFadingDistance()

double inet::SignalFigure::getFadingDistance ( ) const

inline

{ return fadingDistance; }

getFadingFactor()

double inet::SignalFigure::getFadingFactor ( ) const

inline

{ return fadingFactor; }

getRingCount()

int inet::SignalFigure::getRingCount ( ) const

inline

{ return rings.size(); }

getRingSize()

double inet::SignalFigure::getRingSize ( ) const

inline

{ return ringSize; }

getWaveCount()

int inet::SignalFigure::getWaveCount ( ) const

inline

{ return waves.size(); }

getWaveLength()

double inet::SignalFigure::getWaveLength ( ) const

inline

{ return waveLength; }

getWaveOffset()

double inet::SignalFigure::getWaveOffset ( ) const

inline

{ return waveOffset; }

getWaveOpacityFactor()

double inet::SignalFigure::getWaveOpacityFactor ( ) const

inline

{ return waveOpacityFactor; }

getWaveWidth()

double inet::SignalFigure::getWaveWidth ( ) const

inline

{ return waveWidth; }

refresh()

void inet::SignalFigure::refresh

(

)

{
    auto center = bounds.getCenter();
    auto size = bounds.getSize() / 2;
    for (size_t i = 0; i < rings.size(); i++) {
        auto ring = rings[i];
        bool isLast = i == rings.size() - 1;
        double minR = i * ringSize;
        double maxRx = isLast ? DBL_MAX : minR + ringSize;
        double maxRy = isLast ? DBL_MAX : minR + ringSize;
        double innerRx = std::max(minR, std::min(maxRx, this->innerRx));
        double innerRy = std::max(minR, std::min(maxRy, this->innerRy));
        ring->setInnerRx(innerRx);
        ring->setInnerRy(innerRy);
        double outerRx = isLast ? size.x : std::min(size.x, maxRx);
        double outerRy = isLast ? size.y : std::min(size.y, maxRy);
        ring->setBounds(cFigure::Rectangle(center.x - outerRx, center.y - outerRy, 2 * outerRx, 2 * outerRy));
        ring->setVisible(innerRx < outerRx && innerRy < outerRy);
    }
    for (size_t i = 0; i < waves.size(); i++) {
        auto wave = waves[i];
        bool isLast = i == waves.size() - 1;
        double radius = waveOffset + i * waveLength;
        double outerRx = isLast ? size.x : std::min(size.x, radius);
        double outerRy = isLast ? size.y : std::min(size.y, radius);
        wave->setLineWidth(waveWidth);
        wave->setBounds(cFigure::Rectangle(center.x - outerRx, center.y - outerRy, 2 * outerRx, 2 * outerRy));
        wave->setVisible(innerRx < radius && innerRy < radius && radius < size.x && radius < size.y);
    }
    for (size_t i = 0; i < rings.size(); i++)
        rings[i]->setFillOpacity(opacity / pow(fadingFactor, i * ringSize / fadingDistance));
    for (size_t i = 0; i < waves.size(); i++)
        waves[i]->setLineOpacity(waveOpacityFactor * opacity / pow(fadingFactor, i * waveLength / fadingDistance));
}

setBounds()

void inet::SignalFigure::setBounds ( const cFigure::Rectangle &  bounds )

inline

{ this->bounds = bounds; }

setColor()

void inet::SignalFigure::setColor

(

const cFigure::Color &

color

)

{
    for (auto ring : rings)
        ring->setFillColor(color);
    for (auto wave : waves)
        wave->setLineColor(color);
}

setFadingDistance()

void inet::SignalFigure::setFadingDistance ( double  fadingDistance )

inline

{ this->fadingDistance = fadingDistance; }

setFadingFactor()

void inet::SignalFigure::setFadingFactor ( double  fadingFactor )

inline

{ this->fadingFactor = fadingFactor; }

setInnerRx()

void inet::SignalFigure::setInnerRx ( double  innerRx )

inline

{ this->innerRx = innerRx; }

setInnerRy()

void inet::SignalFigure::setInnerRy ( double  innerRy )

inline

{ this->innerRy = innerRy; }

setOpacity()

void inet::SignalFigure::setOpacity ( double  opacity )

inline

{ this->opacity = opacity; }

setRingCount()

void inet::SignalFigure::setRingCount

(

int

count

)

{
    for (int i = 0; i < count; i++) {
        auto ring = new cRingFigure("wave power");
        ring->setFilled(true);
        ring->setOutlined(false);
        rings.push_back(ring);
        addFigure(ring);
    }
}

setRingSize()

void inet::SignalFigure::setRingSize ( double  ringSize )

inline

{ this->ringSize = ringSize; }

setWaveCount()

void inet::SignalFigure::setWaveCount

(

int

count

)

{
    for (int i = 0; i < count; i++) {
        auto wave = new cOvalFigure("wave crest");
        wave->setFilled(false);
        wave->setOutlined(true);
        waves.push_back(wave);
        addFigure(wave);
    }
}

setWaveLength()

void inet::SignalFigure::setWaveLength ( double  waveLength )

inline

{ this->waveLength = waveLength; }

setWaveOffset()

void inet::SignalFigure::setWaveOffset ( double  waveOffset )

inline

{ this->waveOffset = waveOffset; }

setWaveOpacityFactor()

void inet::SignalFigure::setWaveOpacityFactor ( double  waveOpacityFactor )

inline

{ this->waveOpacityFactor = waveOpacityFactor; }

setWaveWidth()

void inet::SignalFigure::setWaveWidth ( double  waveWidth )

inline

{ this->waveWidth = waveWidth; }

Member Data Documentation

bounds

Rectangle inet::SignalFigure::bounds

protected

Referenced by refresh().

fadingDistance

double inet::SignalFigure::fadingDistance = NaN

protected

Referenced by refresh().

fadingFactor

double inet::SignalFigure::fadingFactor = NaN

protected

Referenced by refresh().

innerRx

double inet::SignalFigure::innerRx = NaN

protected

Referenced by refresh().

innerRy

double inet::SignalFigure::innerRy = NaN

protected

Referenced by refresh().

opacity

double inet::SignalFigure::opacity = NaN

protected

Referenced by refresh().

rings

std::vector<cRingFigure *> inet::SignalFigure::rings

protected

Referenced by refresh(), setColor(), and setRingCount().

ringSize

double inet::SignalFigure::ringSize = NaN

protected

Referenced by refresh().

waveLength

double inet::SignalFigure::waveLength = NaN

protected

Referenced by refresh().

waveOffset

double inet::SignalFigure::waveOffset = NaN

protected

Referenced by refresh().

waveOpacityFactor

double inet::SignalFigure::waveOpacityFactor = NaN

protected

Referenced by refresh().

waves

std::vector<cOvalFigure *> inet::SignalFigure::waves

protected

Referenced by refresh(), setColor(), and setWaveCount().

waveWidth

double inet::SignalFigure::waveWidth = NaN

protected

Referenced by refresh().

---

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

• SignalFigure.h
• SignalFigure.cc