Die übersetzung zwischen kartesischen und Bildschirm-Koordinaten

Der grundlegende Algorithmus zum übersetzen von kartesischen Koordinaten in screen-Koordinaten sind

screenX = cartX + screen_width/2
screenY = screen_height/2 - cartY

Aber wie Sie bereits erwähnt, kartesischen Raum ist unendlich, und Ihr Platz auf dem Bildschirm nicht. Dies kann gelöst werden, einfach durch ändern der Auflösung zwischen Platz auf dem Bildschirm und kartesischen Raum. Der obige Algorithmus ist 1-Einheit im kartesischen Raum = 1 Einheit/pixel Platz auf dem Bildschirm. Wenn Sie erlauben, für andere Verhältnisse, können Sie die "zoom" -, oder in Platz auf dem Bildschirm, um alle kartesischen Raum notwendig.

Dies würde sich ändern, die oben beschriebenen Algorithmus zu

screenX = zoom_factor*cartX + screen_width/2
screenY = screen_height/2 - zoom_factor*cartY

Nun behandeln Sie negative (oder zu große) screenX und screenY durch ändern der zoom-Faktor, bis alle Ihre kartesischen Koordinaten auf den Bildschirm passen.

Könnte man auch ermöglichen das schwenken des Koordinatenraum zu, Bedeutung, so dass die Mitte des kartesischen Raum werden aus der Mitte Ihres Bildschirms. Dies könnte auch helfen, damit Ihr zoom_factor zu bleiben, so dicht wie möglich, aber passen auch die Daten nicht gleichmäßig verteilt um den Ursprung des kartesischen Raum.

Dies würde sich ändern, dass der Algorithmus

screenX = zoom_factor*cartX + screen_width/2 + offsetX
screenY = screen_height/2 - zoom_factor*cartY + offsetY

InformationsquelleAutor MerickOWA

Müssen Sie wissen, die Breite und Höhe des Bildschirms.

Dann können Sie tun:

cartX =   screenX - (width / 2);
cartY = -(screenY - (height / 2));

Und:

screenX =  cartX + (width / 2);
screenY = -cartY + (height / 2);

InformationsquelleAutor Daniel A.A. Pelsmaeker

Habe ich einige boost-c++ - für Sie-basierend auf microsoft-Artikel:
https://msdn.microsoft.com/en-us/library/jj635757(v=vs. 85).aspx

Müssen Sie nur wissen, zwei Bildschirm-Punkte und zwei Punkte in deinem Koordinatensystem. Dann können Sie konvertieren Punkt, von einem system zu einem anderen.

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/triangular.hpp>
#include <boost/numeric/ublas/lu.hpp>
#include <boost/numeric/ublas/io.hpp>

 /* Matrix inversion routine.
 Uses lu_factorize and lu_substitute in uBLAS to invert a matrix */
template<class T>
bool InvertMatrix(const boost::numeric::ublas::matrix<T>& input, boost::numeric::ublas::matrix<T>& inverse)
{
    typedef boost::numeric::ublas::permutation_matrix<std::size_t> pmatrix;

    //create a working copy of the input
    boost::numeric::ublas::matrix<T> A(input);

    //create a permutation matrix for the LU-factorization
    pmatrix pm(A.size1());

    //perform LU-factorization
    int res = lu_factorize(A, pm);
    if (res != 0)
        return false;

    //create identity matrix of "inverse"
    inverse.assign(boost::numeric::ublas::identity_matrix<T> (A.size1()));

    //backsubstitute to get the inverse
    lu_substitute(A, pm, inverse);

    return true;
}

PointF ConvertCoordinates(PointF pt_in,
    PointF pt1, PointF pt2, PointF pt1_, PointF pt2_)
{

    float matrix1[]={
         pt1.X,           pt1.Y,           1.0f,           0.0f,
        -pt1.Y,           pt1.X,           0.0f,           1.0f,
         pt2.X,           pt2.Y,           1.0f,           0.0f,
        -pt2.Y,           pt2.X,           0.0f,           1.0f
    };

    boost::numeric::ublas::matrix<float> M(4, 4);
    CopyMemory(&M.data()[0], matrix1, sizeof(matrix1));

    boost::numeric::ublas::matrix<float> M_1(4, 4);
    InvertMatrix<float>(M, M_1);

    double vector[] = {
        pt1_.X,
        pt1_.Y,
        pt2_.X,
        pt2_.Y
    };

    boost::numeric::ublas::vector<float> u(4);
    boost::numeric::ublas::vector<float> u1(4);
    u(0) = pt1_.X;
    u(1) = pt1_.Y;
    u(2) = pt2_.X;
    u(3) = pt2_.Y;

    u1 = boost::numeric::ublas::prod(M_1, u);

    PointF pt;
    pt.X = u1(0)*pt_in.X + u1(1)*pt_in.Y + u1(2);
    pt.Y = u1(1)*pt_in.X - u1(0)*pt_in.Y + u1(3);
    return pt;
}

InformationsquelleAutor Serov Danil