qt rotations around the x- and y-axes - c++

Question

Qt uses a 3x3 transformation matrix for both perspective and affine transformations. A matrix is considered affine if the last row of the matrix equals [0 0 1]. For this reason, the x- and y-axis rotation matrices are "non-affine" and perspective distortion results. But there are further implications. Every pixel the user paints has the coordinates (x, y, 1). There is no way to set the z coordinate to 0, rotate and set z to something else after. Is it still possible to somehow fake being able to rotate around an arbitrary point? Perhaps by setting z to some value "close" to zero and then rotating?
EDIT:
What I want to do, exactly. By crossing out the 3rd row and column of the "usual" perspective projection matrix, one can obtain one usable with Qt. I also use a window matrix to transform into the QGraphicsItem. That makes for 2 matrices for now:
window * projection
Some code:
float const w(rect.width());
float const h(rect.height());
// aspect ratio
auto const ar(h / w);
// symmetrical infinite frustum
f_[4] = 1.f;
f_[1] = ::std::tan(.5f * hFov_) * f_[4];
f_[0] = -f_[1];
f_[3] = ar * f_[1];
f_[2] = -f_[3];
// perspective projection matrix
auto const rml(f_[1] - f_[0]);
auto const tmb(f_[3] - f_[2]);
::etl::matrix<float, 3, 3> const pMatrix{
2.f * f_[4] / rml, 0.f , (f_[1] + f_[0]) / rml,
0.f , 2.f * f_[4] / tmb, (f_[3] + f_[2]) / tmb,
0.f , 0.f , -1.f};
auto const halfW(.5f * w);
auto const halfH(.5f * h);
// window matrix
::etl::matrix<float, 3, 3> const wMatrix{
halfW, 0.f , halfW,
0.f , -halfH, halfH,
0.f , 0.f , 1.f};
wpvMatrix_ = wMatrix * pMatrix;
Now we want to transform a QPixmap into the world we project. This is done, for example with this matrix:
zMatrix =
worldPixmapWidth / pixmap.width(), 0, p(0),
0, -worldPixmapHeight / pixmap.height(), p(1),
0, 0, p(2);
So we can use wMatrix * pMatrix * zMatrix to transform the pixmap.
p is the point we want to translate the QPixmap to. Now that the pixmap is at p = (p(0), p(1), p(2)). We would like to rotate around an axis parallel to the y axis, going through p. How to do it? Usually, we would do T(p) * Ry(phi) * T(-p), but we can't, as there is no translation matrix, that could set the z coordinate. Applying Ry directly will rotate around the origin. Even without doing any transformations at all, z will be 1, not 0, as we would like it to be for Ry.

Answer 1

How to rotate a vertex around a certain point?
The order of when you do a translation, then a rotation, and then translating back will effectively rotate about whatever point you translate to and from.
This applies the same way with matrix transformations and the order that they are called and applied.
UPDATE:
After reading your question over again, it sounds like what you are really asking for is a 3D projection of a QPixmap to simulate it in the process of flipping over, like a playing card flipping over in a card game. This rotation about some axis parallel to the y-axis needs to show the proper distortions to make it look like one side of the image is farther away and the other side is closer.
http://en.wikipedia.org/wiki/3D_projection
Qt's rotations plan on you using the third 3x3 matrix in the equation above. Rotations about the z axis.
Or even more specifically, you can see it here:
http://qt-project.org/doc/qt-5.1/qtgui/qmatrix.html#details, it shows the 2x2 matrix with added rows to account for a translation.
Now with all that being said... this is the closest thing I could find for faking it without using a full on 3D graphics library, like OpenGL:
http://qt-project.org/forums/viewthread/18615/
http://gerrysweeney.com/horizontal-and-vertical-flip-transformations-of-a-qgraphicsitem-in-qt-qgraphicsview/
main.cpp
#include "mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
mainwindow.h
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QtGui>
#include <QPropertyAnimation>
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow(QWidget *parent = 0);
~MainWindow();
QGraphicsScene * m_pScene;
QGraphicsView * m_pView;
QSlider * sliderx;
QSlider * slidery;
QGraphicsPolygonItem* transformedItem;
QPointF itemCenter;
public slots:
void updateRotation();
};
#endif // MAINWINDOW_H
mainwindow.cpp
#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
this->setCentralWidget(new QWidget);
QVBoxLayout * layout = new QVBoxLayout;
m_pScene = new QGraphicsScene(0,0,800,480);
m_pView = new QGraphicsView(m_pScene);
m_pView->setFrameStyle(QFrame::NoFrame);
m_pView->setGeometry(0,0,800,480);
m_pView->setAutoFillBackground(false);
layout->addWidget(m_pView);
sliderx = new QSlider(Qt::Horizontal);
slidery = new QSlider(Qt::Horizontal);
sliderx->setRange(-100,100);
sliderx->setSingleStep(1);
sliderx->setValue(100);
slidery->setRange(-100,100);
slidery->setSingleStep(1);
slidery->setValue(100);
QObject::connect(sliderx, SIGNAL(valueChanged(int)),this, SLOT(updateRotation()));
QObject::connect(slidery, SIGNAL(valueChanged(int)),this, SLOT(updateRotation()));
layout->addWidget(sliderx);
layout->addWidget(slidery);
this->centralWidget()->setLayout(layout);
QPolygonF polygon;
polygon << QPointF(100.0,250.0);
polygon << QPointF(170.0, 350.0);
polygon << QPointF(30.0, 350.0);
QGraphicsPolygonItem* testItem = new QGraphicsPolygonItem(polygon);
m_pScene->addItem(testItem);
transformedItem = new QGraphicsPolygonItem(polygon);
transformedItem->setPen(QColor(Qt::red));
m_pScene->addItem(transformedItem);
// Here the fun starts:
itemCenter = transformedItem->mapToParent(transformedItem->boundingRect().center());
// // Method 1
// QTransform transform = QTransform();
// transform.translate(itemCenter.x(),
// itemCenter.y());
// transform.scale(1.0, -1.0);
// transform.translate(-itemCenter.x(),
// -itemCenter.y());
// transformedItem->setTransform(transform);
// // Method 2
// transformedItem->setTransform(QTransform::fromTranslate(itemCenter.x(),
// itemCenter.y()),true);
// transformedItem->setTransform(QTransform::fromScale(1.0, -1.0),true);
// transformedItem->setTransform(QTransform::fromTranslate(-itemCenter.x(),
// -itemCenter.y()), true);
// // Method 3
// transformedItem->translate(itemCenter.x(),
// itemCenter.y());
// transformedItem->scale(1.0, -1.0);
// transformedItem->translate(-itemCenter.x(),
// -itemCenter.y());
}
void MainWindow::updateRotation()
{
transformedItem->resetTransform();
transformedItem->translate(itemCenter.x(),
itemCenter.y());
transformedItem->scale((qreal)sliderx->value()/100., (qreal)slidery->value()/100.);
transformedItem->translate(-itemCenter.x(),
-itemCenter.y());
}
MainWindow::~MainWindow() { }
Hope that helps.