Итак, проблема сводится к следующему:

Я знаю 4 точки A,B,C,D и хочу вычислить матрицу преобразования, которая преобразует A,B в C,D.

Это можно сделать так. Предположим, мы конвертируем точки следующим образом:

M * A = C
M * B = D

Где M - вне матрицы преобразования, которую мы хотим вычислить. Существует бесконечное количество возможных решений (поскольку линия AB может иметь любое вращение вокруг собственной оси)

Если вы немного рассечете букву M, это всего лишь вопрос знания положения, ориентации и масштаба.

1. Масштаб самый простой

   это просто отношение длины строки после и до преобразования.

   scale = |CD|/|AB|
   

2. ориентация

   он представлен единичными базисными векторами. Мы можем использовать тот факт, что AB и CD имеют только одно вращение (все остальные просто производят бесконечное количество решений), поэтому мы можем просто повернуть AB на угол между _9 _, _ 10_ вокруг оси, перпендикулярной обоим _11 _, _ 12_. Угол, который мы можем получить с помощью скалярного произведения между единичными векторами, параллельными _13 _, _ 14_. Единственная проблема в том, что это не даст нам направления вращения, поэтому нам нужно проверить две возможности (CW, CCW).

   so:

    axis  = cross(B-A,D-C)
    angle = +/- acos(dot(B-A,D-C) / |B-A|*|D-C|)
   

3. перевод

   это просто, мы просто преобразуем A в M без перевода, давайте назовем его A', а затем просто исправим полученную позицию, чтобы она перешла в C.

   M_origin += C-A'
   

   Помните, что перевод должен быть установлен напрямую, без применения матрицы перевода. Обычно они переводятся в локальной системе координат [LCS], которая включает в себя сначала преобразование разницы в нее. В таком случае используйте

   translate(Inverse(M)*(C-A'))
   

   or

   translate(M*(C-A'))
   

   в зависимости от используемых обозначений.

Вот небольшой пример C ++ / VCL / старого GL:

//---------------------------------------------------------------------------
#include <vcl.h>
#include <math.h>
#pragma hdrstop
#include "Unit1.h"
#include "gl_simple.h"
#include "OpenGLrep4d_double.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
double arot=0.0;                // just animation angle
//---------------------------------------------------------------------------
const int pnts=8;
double pnt[pnts*3]=             // Vertexes for 10x10x10 cube centered at (0,0,0)
    {
    -5.0,-5.0,-5.0,
    -5.0,+5.0,-5.0,
    +5.0,+5.0,-5.0,
    +5.0,-5.0,-5.0,
    -5.0,-5.0,+5.0,
    -5.0,+5.0,+5.0,
    +5.0,+5.0,+5.0,
    +5.0,-5.0,+5.0,
    };
const int lins=12;
int lin[lins*2]=                // lines (index of point used) no winding rule
    {
    0,1,1,2,2,3,3,0,
    4,5,5,6,6,7,7,4,
    0,4,1,5,2,6,3,7,
    };
double A[3]={-5.0,-5.0,-5.0};   // cube diagonal
double B[3]={+5.0,+5.0,+5.0};
double C[3]={-4.5, 2.0, 0.0};   // wanted cube diagonal
double D[3]={+4.5, 5.0, 0.0};
double M[16];                   // our transform matrix
//---------------------------------------------------------------------------
void compute_M()
    {
    double scale,p[3],q[3],n[3],a;
    const double deg=180.0/M_PI;
    const double rad=M_PI/180.0;
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();

    // scale
    vector_sub(p,B,A);                      // p=B-A
    vector_sub(q,D,C);                      // q=D-C
    scale=vector_len(q)/vector_len(p);      //  =|q|/|p|

    // rotation between AB and CD
    vector_mul(n,p,q);                      // n = (p x q) ... cross product
    vector_one(p,p);                        // p = p/|p|
    vector_one(q,q);                        // q = q/|q|
    a=acos(vector_mul(p,q));                // angle between AB and CD in [rad]

    glLoadIdentity();                       // unit matrix
    glRotated(+a*deg,n[0],n[1],n[2]);       // rotate by angle around normal to AB,CD
    glScaled(scale,scale,scale);            // apply scale
    glGetDoublev(GL_MODELVIEW_MATRIX,M);    // get the M from OpenGL

    // translation
    matrix_mul_vector(p,M,A);               // p = M*A
    vector_sub(p,C,p);                      // p = C-p
    M[12]=p[0];
    M[13]=p[1];
    M[14]=p[2];
    M[15]=1.0;

    // verify
    matrix_mul_vector(p,M,B);               // p = M*B
    vector_sub(p,p,D);                      // p = p-C
    if (vector_len(p)>1e-3)                 // if |p| too big use other direction to rotate
        {
        glLoadIdentity();                       // unit matrix
        glRotated(-a*deg,n[0],n[1],n[2]);       // rotate by angle around normal to AB,CD
        glScaled(scale,scale,scale);            // apply scale
        glGetDoublev(GL_MODELVIEW_MATRIX,M);    // get the M from OpenGL
        }

    glPopMatrix();
    }
//---------------------------------------------------------------------------
void gl_draw()      // main rendering code
    {
    int i;
    double m0[16],m1[16],m[16],x[3],y[3],z[3],t2[3][3];

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glDisable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslated(0.0,0.0,-50.0);
    glRotated(15.0,1.0,0.0,0.0);
    glRotated(arot,0.0,1.0,0.0);

    glBegin(GL_LINES);
    glColor3f(1.0,0.0,0.0); for (i=0;i<lins*2;i++) glVertex3dv(pnt+(lin[i]*3)); // render original cube
    glColor3f(0.0,1.0,0.0); glVertex3dv(A); glVertex3dv(B);                     // render original diagonal AB
    glColor3f(1.0,1.0,0.0); glVertex3dv(C); glVertex3dv(D);                     // render wanted diagonal CD
    glEnd();

    // render transformed cube
    glMatrixMode(GL_MODELVIEW);
    glMultMatrixd(M);
    glBegin(GL_LINES);
    glColor3f(0.0,0.0,1.0); for (i=0;i<lins*2;i++) glVertex3dv(pnt+(lin[i]*3)); // render transformed cube
    glEnd();


    glFlush();
    SwapBuffers(hdc);
    }
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
    {
    // application init
    gl_init(Handle);
    compute_M();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
    {
    // application exit
    gl_exit();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
    {
    // window resize
    gl_resize(ClientWidth,ClientHeight);
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
    {
    // window repaint
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
    {
    arot+=1.5; if (arot>=360.0) arot-=360.0;
    gl_draw();
    }
//---------------------------------------------------------------------------

Просто игнорируйте вещи, связанные с VCL. Функции поддержки GL вы можете найти здесь:

• полный пример GL + GLSL + VAO / VBO C ++

Единственное, что здесь важно, это compute_M() вместе с глобальными переменными.

Векторные математические функции прокомментированы (так что вы можете перевести это в GLM), если вам нужны реализации, вы можете найти их в связанном выше QA. Это в основном занимает. Для простоты я использовал собственные повороты GL (будьте осторожны, они выражаются в градусах, а не в радианах).

Вот превью:

• red - оригинальный куб
• green - оригинальная диагональ AB
• blue преобразованный куб M
• yellow требуется диагональ CD

Как видите, он совпадает.

Если вам нужно выровнять больше, чем просто линию, вам нужно добавить дополнительную информацию для выравнивания (например, 2 линии (3 точки)) и т. Д. Для получения дополнительной информации см.

• Проблемы с наложением и выравниванием трехмерных треугольников