Russian Qt Forum

C++ (Qt)
qreal dot = a.x*b.x+a.y*b.y; 
 

C++ (Qt)
qreal cross = (p.x-p1.x) * (p2.y-p1.y) - (p2.x-p1.x) * (p.y-p1.y);
 

C++ (Qt)
float height( int x, int y ) {  return brightness(x, y, theImage) * theAmplitude;  }

C++ (Qt)
p0 = { x, y, height(x, y) };  // сама точка
p1 = { x + 1, y, height(x + 1, y) };  // сосед справа
p2 = { x, y + 1, height(x, y + 1) };  // сосед сверху
 

C++ (Qt)
N = cross(p1 - p0, p2 - p0).normalize();

C++ (Qt)
double h = 10.0;
double n_12 = 1.0 / 1.33 // относительный показатель преломления воздуха по отношению к воде.. (к дистиллированной при 20 C)
 
double r = h * n_12/sqrt(1.0 - n_12*n_12); 
 

C++ (Qt)
#include <QApplication>
#include <QGLWidget>
#include <QWheelEvent>
#include <QMouseEvent>
#include <QDebug>
 
class Magnifier : public QGLWidget
{
public:
    Magnifier(QWidget* parent = 0) :
        QGLWidget(parent)
    {
        for (int i = 0; i < 5; i++)
            for (int j = 0; j < 10; j++)
            {
                points[(i * 10 + j) * 3] =  -0.8f + (i % 2) * 0.2f + j * 1.6f / 10.0f;
                points[(i * 10 + j) * 3 + 1] = -0.8f + i * 1.6f / 5.0f;
                points[(i * 10 + j) * 3 + 2] = 0.0f;
            }
        top = left = -1.0;
        mag = 1.0;
        countMagWindow(0, 0);
        setMouseTracking(true);
    }
    void initializeGL()
    {
        glClearColor(0.0f, 0.0f, 0.1f, 1.0f);
        glPointSize(3.0f);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
    }
 
    void resizeGL(int w, int h)
    {
        glViewport(0, 0, w, h);
    }
 
    void paintGL()
    {
        glLoadIdentity();
        glOrtho(left, left + 2.0 / mag, top + 2.0 / mag, top, -1.0, 1.0);
 
        glClear(GL_COLOR_BUFFER_BIT);
        glColor3f(1.0f, 0.0f, 0.0f);
        glEnableClientState(GL_VERTEX_ARRAY);
        glVertexPointer(3, GL_FLOAT, 0, points);
        glDrawArrays(GL_POINTS, 0, 50);
        glDisable(GL_VERTEX_ARRAY);
 
        glColor3f(0.0f, 1.0f, 0.0f);
        glBegin(GL_LINES);
            glVertex2d(magLeft, magTop);
            glVertex2d(magLeft, magTop + 2.0 / mag / 1.1);
            glVertex2d(magLeft, magTop + 2.0 / mag / 1.1);
            glVertex2d(magLeft + 2.0 / mag / 1.1, magTop + 2.0 / mag / 1.1);
            glVertex2d(magLeft + 2.0 / mag / 1.1, magTop + 2.0 / mag / 1.1);
            glVertex2d(magLeft + 2.0 / mag / 1.1, magTop);
            glVertex2d(magLeft + 2.0 / mag / 1.1, magTop);
            glVertex2d(magLeft, magTop);
        glEnd();
 
    }
    void mouseMoveEvent(QMouseEvent *event)
    {
        qDebug() << QString("x: %1, y: %2").arg(event->x()).arg(event->y());
        countMagWindow(event->x(), event->y());
        updateGL();
    }
 
    void wheelEvent(QWheelEvent *event)
    {
        if (event->delta() > 0)     //от себя
        {
            left = magLeft;
            top = magTop;
            mag *= 1.1;
        }
        else
        {
            countUnMagWindow(event->x(), event->y());
            left = magLeft;
            top = magTop;
            mag /= 1.1;
        }
        countMagWindow(event->x(), event->y());
        updateGL();
    }
 
    void countMagWindow(int x, int y)
    {
        double futureMag = mag * 1.1;
        double right = left + 2.0 / futureMag,
               bottom = top + 2.0 / futureMag;
        magLeft = (right - left) * x / width() * (1.0 / 11.0) + left;
        magTop = (bottom - top) * y / height() * (1.0 / 11.0) + top;
    }
 
    void countUnMagWindow(int x, int y)
    {
        double futureMag = mag / 1.1;
        double right = left + 2.0 / futureMag,
               bottom = top + 2.0 / futureMag;
        magLeft = (right - left) * x / width() * (-0.1) + left;
        magTop = (bottom - top) * y / height() * (-0.1) + top;
    }
 
private:
    float points[50 * 3];
    double top, left, mag,
           magTop, magLeft;
};
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Magnifier w;
    w.show();
 
    return a.exec();
}
 

C++ (Qt)
QVector3D v0, v1;
..
float a1 = QVector3D::dotProduct(v0, v1) / (v0.length() * v1.length()); 
float a2 = QVector3D::dotProduct(v0, v1) / v0.length(); 
float a3 = QVector3D::dotProduct(v0, v1) / v0.lengthSquared(); 
QVector v2 = v0 * a3;
QVector v3 = v1 - v2;
 

C++ (Qt)
#include <QtWidgets>
 
inline float RandF( void )
{
	return float(qrand()) / RAND_MAX - 0.5f;
}
 
int main(int argc, char *argv[])
{
	qsrand(0);	
	const int num = 1000 * 1024;
	double sum[5] = { 0.0 };
	for (int i = 0; i < num; ++i) {
		QVector3D vec(RandF(), RandF(), RandF());
		vec.normalize();
		double x2 = vec.x() * vec.x();
		double y2 = vec.y() * vec.y();
		double z2 = vec.z() * vec.z();
		sum[0] += x2;
		sum[1] += x2 * x2;
		sum[2] += x2 * y2;
		sum[3] += x2 * z2;
	}
	for (int i = 0; i < 4; ++i)
		qDebug() << (sum[i] / num) << "/" << (num / sum[i]); 
 
	return 0;
}
 

C++ (Qt)
QVector3D vec(RandF(), RandF(), RandF());
vec.normalize();
 

C++ (Qt)
QVector3D RandomVec( void )
{
 float theta = float(qrand()) / RAND_MAX * M_PI;   // случайный "угол возвышения"
 float phi = float(qrand()) / RAND_MAX * M_PI * 2;   // случайный "азимут"
 return QVector3D(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta)); 
}

C++ (Qt)
inline float RandF( void )
{
	return float(qrand()) / RAND_MAX * 2 - 1;
}
 
QVector3D RandVec( void )
{
	while (true) {
		QVector3D vec(RandF(), RandF(), RandF());
		float len = vec.length();
		if (len <= 1.0f) return vec / len;
	}
}

C++ (Qt)
static const double pi = 4.0*atan(1.0);
 
inline double sign(const double & x) { return (x >= 0.0) ? 1 : -1; }
 
 
int main()
{
    random_device rd;
    mt19937 gen(rd());
 
    uniform_real_distribution<double> phi_dist(0.0, 2.0*pi); // распределение для угла phi
    uniform_real_distribution<double> z_dist(-1.0, 1.0); // распределение для проекции вектора на ось z
 
 
    const int num = 1000 * 1024;
    double sum[5] = { 0.0 };
    for (int i = 0; i < num; ++i)
    {
        double z = z_dist(gen);
        double phi = phi_dist(gen);
 
        double x = sign(z)*sqrt(1.0 - z*z)*cos(phi);
        double y = sign(z)*sqrt(1.0 - z*z)*sin(phi);
 
 
        double x2 = x*x;
        double y2 = y*y;
        double z2 = z*z;
        sum[0] += x2;
        sum[1] += x2 * x2;
        sum[2] += x2 * y2;
        sum[3] += x2 * z2;
    }
    for (int i = 0; i < 4; ++i)
        cout << (sum[i] / num) << endl;
 
    return 0;
}
 

C++ (Qt)
static constexpr double pi = 4.0*atan(1.0);

C++ (Qt)
struct Ball {
 QVector3D m_position;
 QVector3D m_speed;
 static float radius;
};

C++ (Qt)
bool BallsCollided( Ball & ball1, Ball & ball2 )
{
// Если шарики столкнулись то вернуть true
// и рассчитать новые скорости шариков
}

C++ (Qt)
bool BallsCollided( Ball & ball1, Ball & ball2 )
{
    QVector3D r0 = ball1.pos - ball2.pos;
    QVector3D u = ball1.speed - ball2.speed;
 
    float u2 = u.lengthSquared();
    float r0u = QVector3D::dotProduct(r0, u);
 
    float rho2 = r0.lengthSquared() - r0u*r0u/u2;
 
    return (rho2 < 4*Ball::radius * Ball::radius);
}
 

C++ (Qt)
bool BallsCollided( Ball & ball1, Ball & ball2 )
{
    QVector3D r0 = ball1.pos - ball2.pos;
    QVector3D u = ball1.speed - ball2.speed;
 
    float u2 = u.lengthSquared();
    float r0u = QVector3D::dotProduct(r0, u);
 
    float rho2 = r0.lengthSquared() - r0u*r0u/u2;
 
    return (rho2 < 4*Ball::radius * Ball::radius);
}
 

C++ (Qt)
Ball b1, b2;
 
// первый шарик справа и движется вправо
b1.position = QVector3D(1, 0, 0):
b1.speed = QVector3D(1, 0, 0):
 
// а второй стоит в (0, 0, 0)
b2.position = QVector3D(0, 0, 0):
b2.speed = QVector3D(0, 0, 0):
 
Ball::radius = 0.4f;
bool collided = BallCollided(b1, b2);

C++ (Qt)
bool BallsCollided( Ball & b1, Ball & b2 )
{
    if ((b1.position - b2.position).length() > Ball::radius * 2)  // не пересеклись?
     return false;
 
// пересеклись, считаем новые скорости
 
    return true;
}
 

C++ (Qt)
while (true) {
  BallsCollided(b1, b2);
  b1.position += b1.speed * dt;   // часто для простоты dt = 1
  b2.position += b2.speed * dt; 
}

C++ (Qt)
bool BallsCollided( Ball & ball1, Ball & ball2 )
{
    QVector3D r0 = ball1.pos - ball2.pos;
    QVector3D u = ball1.speed - ball2.speed;
 
    float u2 = u.lengthSquared();
    float r0u = QVector3D::dotProduct(r0, u);
 
    float rho2 = r0.lengthSquared() - r0u*r0u/u2;
 
    return (rho2 < 4.0*Ball::radius * Ball::radius) & (r0u < 0.0f);
}
 

C++ (Qt)
ball.position += ball.speed;
 

C++ (Qt)
bool BallsCollded( Ball & b1, Ball & b2, float dt = 1.0f )
{
// находим напр-е AB
  QVector3D vecAB = b1.speed - b2.speed;
  float curSpeed = vecAB.length();
 
// убедимся что разница скоростей достаточно велика 
  const double minSpeed = 1.0e-7;
  if (curSpeed < minSpeed) return false;
  vecAB /= curSpeed;
 
// находим длину AB как проекцию AC на напр-е AB
 QVector3D vecAC = b1.position - b2.position;
 float lenAB = QVector3D::dotProduct(vecAC, vecAB);
 
// если lenAB отрицательна, то шары расходятся
 if (lenAB <= 0) return false;
 
// по теореме Пифагора находим квадрат длины катета BC
 float lenBC2 = vecAC.lengthSquared() - lenAB * lenAB;
 
// если lenBC2 < квадрата (двойного) радиуса, то шарики никогда не пересекутся
 float R2 = Ball:radius * Ball:radius * 4;
 if (lenBC2 > R2) return false;
 
// из тр-ка DBC найдем длину BD
 float lenBD = sqrt(R2 - lenBC2);
 
// длина AD = время первого касания
 float t0 = lenAB - lenBD;
 
// успеют ли шарики столкнуться за время dt ?
 if (t0 * dt > curSpeed) return false;
 
// столкнулись, рассчитываем новые скорости
  ...
  return true;
}
 

C++ (Qt)
// длина AD = время первого касания
 float t0 = lenAB - lenBD;
 
// успеют ли шарики столкнуться за время dt ?
 if (t0 * dt > curSpeed) return false;
 

C++ (Qt)
// длина AD = время первого касания
 float lenAD = lenAB - lenBD;
 
// успеют ли шарики столкнуться за время dt ?
 if ( lenAD > curSpeed * dt ) return false;
 

C++ (Qt)
#include <QCoreApplication>
#include <QMatrix4x4>
#include <QDebug>
 
 
int main()
{
    QMatrix4x4 viewportMatrix;
    viewportMatrix.viewport(0, 0, 100, 100);  // {0, 0} is bottomLeft
 
    QMatrix4x4 projectionMatrix; // identity
 
    QMatrix4x4 modelViewMatrix;
    modelViewMatrix.rotate(45, 0, 0, 1);
 
 
    const QVector4D vec (1, 0, 0, 1);
 
    const QMatrix4x4 modelViewProjectionMatrix = projectionMatrix * modelViewMatrix;
 
    const QVector4D modelViewProjectedVec = modelViewProjectionMatrix * vec;
    qDebug() << modelViewProjectedVec;
    qDebug() << viewportMatrix * modelViewProjectedVec;
 
    return 0;
}
 

C++ (Qt)
inline QVector2D CameraPoint2Screen( const QVector3D & src, float scale, bool perspectiveFlag )
{
  return src * (scale / (perspectiveFlag ? -src.z() : 1.0f));
}

C++ (Qt)
void GeometryEngine::PrintVertices(const QMatrix4x4 & mvp , const QMatrix4x4 &viewport)
{
	int count = sizeof(vertices) / sizeof(vertices[0]);
	for (int i = 0; i < count; ++i) {
		QVector4D ver(vertices[i].position, 1.0f);
		ver = mvp * ver;
        ver /= ver.w();
//        ver = viewport * ver; // screen coordinates
		qDebug() << i << ver;
	}
	qDebug() << "end";
}
 

C++ (Qt)
inline QVector3D Screen2CameraPoint( const QVector2D & screen, float scale, bool perspectiveFlag )
{
  if (perspectiveFlag)
   return QVector3D(screen.x(), screen.y(), -scale);
  else   
   return screen / scale;
}
 

C++ (Qt)
void DrawTriangleRGB( QPainter & painter, const QPointF pt[3] )
{
 ???
}

C++ (Qt)
QMatrix4x4 GetTransform2D( const QVector3D & a, const QVector3D & b, const QVector3D & c )
{
 // находим ось поворота
 QVector3D normal = QVector3D::normal(a, b, c);
 QVector3D axis = QVector3D::crossProduct(normal, QVector3D(0, 0, 1));
 
 // находим угол поворота
 // cos(angle) = dot(normal, QVector3D(0, 0, 1)) = normal.z
 float angle = acos(normal.z) * 180 / M_PI;
 
 // получаем матрицу поворота
 QMatrix4x4 M;
 M.rotate(angle, axis);
 
 // учтем смещение
 M.translate(-a);
 
 return M;
}

C++ (Qt)
QVector3D center = matrix.inverted() * QVector3D();

C++ (Qt)
local_point = matrix * source_point