160 lines
2.7 KiB
C++
160 lines
2.7 KiB
C++
#include "renderarea.h"
|
|
#include <QPainter>
|
|
|
|
RenderArea::RenderArea(QWidget *parent) :
|
|
QWidget{parent},
|
|
mBackgroundColour{36,35,35},
|
|
mShapeColour{251,250,250},
|
|
mShape{Astroid}
|
|
{
|
|
OnShapeChanged();
|
|
}
|
|
|
|
QPointF RenderArea::ComputeAstroid(double t){
|
|
return QPointF{
|
|
2*pow(cos(t),3),
|
|
2*pow(sin(t),3)
|
|
};
|
|
}
|
|
|
|
QPointF RenderArea::ComputeCycloid(double t)
|
|
{
|
|
return QPointF{
|
|
1.5 * (1 - cos(t)),
|
|
1.5 * (t - sin(t))
|
|
};
|
|
}
|
|
|
|
QPointF RenderArea::ComputeHuygens(double t)
|
|
{
|
|
return QPointF{
|
|
4 * (3 * cos(t) - cos(3 * t)),
|
|
4 * (3 * sin(t) - sin(3 * t))
|
|
};
|
|
}
|
|
|
|
QPointF RenderArea::ComputeHypo(double t)
|
|
{
|
|
return QPointF{
|
|
1.5 * (2 * cos(t) + cos(2 * t)),
|
|
1.5 * (2 * sin(t) - sin(2 * t))
|
|
};
|
|
}
|
|
|
|
QPointF RenderArea::ComputeLine(double t)
|
|
{
|
|
return QPointF{1-t,1-t};
|
|
}
|
|
|
|
QSize RenderArea::minimumSizeHint() const
|
|
{
|
|
return QSize(100,100);
|
|
}
|
|
|
|
QSize RenderArea::sizeHint() const
|
|
{
|
|
return QSize(400,200);
|
|
}
|
|
|
|
void RenderArea::setInternalLenght(double l)
|
|
{
|
|
mIntervalLenght = l;
|
|
}
|
|
|
|
void RenderArea::setScale(double s)
|
|
{
|
|
mScale = s;
|
|
}
|
|
|
|
void RenderArea::setStepCount(double s)
|
|
{
|
|
mStepCount = s;
|
|
}
|
|
|
|
void RenderArea::paintEvent(QPaintEvent* event)
|
|
{
|
|
QPainter painter{this};
|
|
painter.setRenderHint(QPainter::Antialiasing,true);
|
|
|
|
painter.setBrush(mBackgroundColour);
|
|
painter.setPen(mShapeColour);
|
|
|
|
painter.drawRect(this->rect());
|
|
|
|
QPointF prevPoint{Compute(0)};
|
|
QPoint center{this->rect().center()},prevPixel;
|
|
prevPixel.setX(prevPoint.x() * mScale + center.x());
|
|
prevPixel.setY(prevPoint.y() * mScale + center.y());
|
|
|
|
double step{ mIntervalLenght / mStepCount };
|
|
|
|
for(float t = 0; t < mIntervalLenght; t += step){
|
|
QPointF point = Compute(t);
|
|
|
|
QPoint pixel;
|
|
pixel.setX(point.x() * mScale + center.x());
|
|
pixel.setY(point.y() * mScale + center.y());
|
|
|
|
painter.drawLine(pixel, prevPixel);
|
|
|
|
prevPixel=pixel;
|
|
}
|
|
}
|
|
|
|
void RenderArea::OnShapeChanged()
|
|
{
|
|
switch (mShape) {
|
|
case Astroid:
|
|
mScale=50;
|
|
mIntervalLenght=2*M_PI;
|
|
mStepCount=512;
|
|
break;
|
|
case Cycloid:
|
|
mScale=10;
|
|
mIntervalLenght=6*M_PI;
|
|
mStepCount=128;
|
|
break;
|
|
case HuygensCycloid:
|
|
mScale=10;
|
|
mIntervalLenght=4*M_PI;
|
|
mStepCount=512;
|
|
break;
|
|
case HypoCycloid:
|
|
mScale=50;
|
|
mIntervalLenght=2*M_PI;
|
|
mStepCount=256;
|
|
break;
|
|
case Line:
|
|
mScale=50;
|
|
mIntervalLenght=1;
|
|
mStepCount=128;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
QPointF RenderArea::Compute(double t)
|
|
{
|
|
switch (mShape) {
|
|
case Astroid:
|
|
return ComputeAstroid(t);
|
|
break;
|
|
case Cycloid:
|
|
return ComputeCycloid(t);
|
|
break;
|
|
case HuygensCycloid:
|
|
return ComputeHuygens(t);
|
|
break;
|
|
case HypoCycloid:
|
|
return ComputeHypo(t);
|
|
break;
|
|
case Line:
|
|
return ComputeLine(t);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return QPointF{0,0};
|
|
}
|