La conversion entre cartésiens et les coordonnées de l'écran

L'algorithme de base de traduire à partir des coordonnées cartésiennes en coordonnées d'écran sont

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

Mais comme vous l'avez mentionné, cartésien de l'espace est infini, et votre espace à l'écran ne l'est pas. Ceci peut être facilement résolu en changeant la résolution entre l'écran de l'espace et de l'espace cartésien. L'algorithme ci-dessus fait 1 unité dans l'espace cartésien = 1 unité/pixel dans l'espace de l'écran. Si vous le permettez pour d'autres ratios, vous pouvez "zoomer" ou dans votre espace à l'écran pour couvrir l'ensemble de l'espace cartésien nécessaire.

Ce serait changer l'algorithme ci-dessus pour

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

Maintenant, vous gérer les négatifs (ou trop larges) screenX et screenY en modifiant votre facteur de zoom jusqu'à ce que toutes vos coordonnées cartésiennes tiendra sur l'écran.

Vous pourrait également permettre d'panoramique de l'espace de coordonnées, de façon à ce, permettant au centre de l'espace cartésien à être au centre de l'écran. Cela pourrait aussi aider en permettant à votre zoom_factor de rester aussi serré que possible, mais également d'ajustement des données qui n'est pas uniformément répartie autour de l'origine de l'espace cartésien.

Ce serait de modifier l'algorithme pour

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

OriginalL'auteur MerickOWA

Vous besoin de connaître la largeur et la hauteur de l'écran.

Alors vous pouvez faire:

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

Et:

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

OriginalL'auteur Daniel Pelsmaeker

J'ai un peu de boost c++ pour vous, basé sur l'article de microsoft:
https://msdn.microsoft.com/en-us/library/jj635757(v=vs. 85).aspx

Vous avez juste besoin de la connaissance de deux points de l'écran et deux points dans votre système de coordonnées. Ensuite, vous pouvez convertir point d'un système à un autre.

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

OriginalL'auteur Serov Danil