QtCurvesCpp/renderarea.cpp

#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))
	};
}

QSize RenderArea::minimumSizeHint() const
{
	return QSize(100,100);
}

QSize RenderArea::sizeHint() const
{
	return QSize(400,200);
}

void RenderArea::paintEvent(QPaintEvent* event)
{
	QPainter painter{this};
	painter.setRenderHint(QPainter::Antialiasing,true);

	painter.setBrush(mBackgroundColour);
	painter.setPen(mShapeColour);

	painter.drawRect(this->rect());

	QPoint center{this->rect().center()};
	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.drawPoint(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;
		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;
		default:
		break;
	}
	return QPointF{0,0};
}