Club Builder

[Gabriel]

A ver si alguien puede ayudarme, porque estoy encabronadísimo y echando

putas por todos lados...
Lo que pasa es lo siguiente: Estoy haciendo una aplicación para dibujar

líneas, puntos, figuras, etc. (si, una estupidez, ya sé, pero es sólo

para aprender y entender cómo cuernos funcionan las ecuaciones), pero

me esta enloqueciendo el hecho de que el origen de coordenadas esté en

el ángulo superior izquierdo. Alguien conoce una manera de que el

origen sea en el centro del área cliente del formulario? O por lo menos

de cambiar el origen en la ecuación correspondiente (ya traté mil

formas y no funcionó, se dibujaron algunas cosas algo graciosas, o

bizarras).
Por ejemplo, para dibujar un píxel a lo largo de las coordenadas de un

círculo se usa una ecuación así (hay otras, pero esta también

funciona):
|cos(a) sin(a)|
(x' y') = (x y) * | |
|-sin(a) cos(a)|

donde 'a' es el ángulo que antes pasé a radianes.
Esto funciona, pero sólo en un pequeño cuadrante en la parte superior

izquierda del formulario, en el sentido de las agujas del reloj. Ahora,

si el origen de coordenadas estuviera en el centro del formulario, esto

debería verse por completo, no sólo una parte.
Todos lo libros y apuntes que tengo dan las ecuaciones y algoritmos

como si el origen funcionara como lo vemos en la escuela:

+y|
-x ___|___ +x
|
-y|

lo cual a mí no me funciona, porque estoy tratando de graficar en una

PC, la que tiene otra idea de cómo tratar a las coordenadas. En fin, si

alguien sabe cómo cambiar el origen, o tiene alguna otra idea de como

graficar, se agradecería el consejo. He visto muchas aplicaciones que

lo hacen, así que no es imposible (es sólo que soy bastante lento). En

fin... AYUDA!!!

[Jose Agustin]

La cosa es muy simple primero que todo se tiene que tener calma para comprender lo de las transformadas, pues estas rotan las figuras en torno a un origen pero el punto donde parte se localiza el origen lo desides tu de la forma mas tonta.

segundo debes de imaginar que tienes dos contextos es decir dos mundos que se relacionan de alguna forma, el mundo de los pixesl o pantalla con sus reglas (2D, valores enteros y el eje vertical negativo o de pa bajo), y el mundo real(donde tu pintas lo que quieres sin limites: es decir muy pequeño 0.00001 o muy grande 123.014E15 y en 3D si quieres)

por ejemplo si tines una pantalla de PC cullas cordenadas van desde (xmin,"ymin") equivalente a las cordenadas del mundo virtual que deseas dibujar (Xmin,"Ymax")
esto en la esquina superior izquierda, y en la derecha para pixels y mundo respectivamente : (xmax,"Ymin"), (Xmax,Ymin).

vemos que las cordenadas en x son positivas en anbos casos pero las y son invertidas unas son positivas en mundo y negativas conrespecto a este mundo en pixels, lo que deves de hacer para solucionar el primer problema es definir una funcion que transforme de pixels a mundo "el mundo virtual reflejado en la pantalla" de la forma siguiente:

// puedes colocar todo esto en una clase para mas facilidad o solo como esta
// claro que lo de las transformaciones te lo dejo para que lo organises bien pero
// pero fijate en los comentarios.

// punto en pixels Pantalla donde queremos el origne de rotacion
// este origen no tiene que ser (0,0,0) puede ser cualquier punto en el espacio
int OringenPixelsX, OrigenPixelsY;

// coordenadas del origne de rotacion que mencione antes
double OrigenMundoX, OrigenMundoY, OrigenMundoZ;

// factor de convercion o relacion dentre mundo y pixels
// si EscalaX==1.5 dibujara 1.5 pixels por cada unidad y así
double EscalaX, EscalaY, EscalaZ;

void DefEscala(double ex, double ey, double ez)
{ // por favor no introducir cero pues genera errores en PixelMundo();
EscalaX=ex;

// puedes cambiar esto por EscalaY=-ey; para corregir lo del eje negativo;
EscalaY=ey;
EscalaZ=ez;
}

void DefOrigenMundo(double x, double y, double z)
{
OrigenMundoX=x, OrigenMundoY=y, OrigenMundoZ=z;
}

void DefOrigenPixels(int x, int y)
{
OringenPixelsX=z, OrigenPixelsY=y; // este y si es positivo por si las dudas
}

void MundoPixels(double x, double y, double z, int&xp, int&yp)
{
// referenciamos el punto del mundo virtual con el punto de rotacion
x-=OrigenMundoX;
y-=OrigenMundoY;
z-=OrigenMundoZ;

// cambiamos la escala
x*=EscalaX;
y*=EscalaY;
z*=EscalaZ;

// aplicamos las transformaciones de senos y cosenos de los libros
xp=(int)( /* funciones de rotacion*/ +0.25/*para corrección*/ +OrignePixelsX);
yp=(int)( /* funciones de rotacion*/ +0.25/*para corrección*/ +OrignePixelsX);
// zp no existe en un mundo plano o mejor dicho es siempre 0.0 pero bueno!
zp=(int)( /* funciones de rotacion*/ +0.25/*para corrección*/ +OrignePixelsX);
}

void PixelMundo(int xp, int yp, /*zp==0 o si lo quieres poner*/, double&x, double&y, double&z)
{//del mismo modo que la enterior pero guardando las relaciones matematicas
// trasladamos al origen real de rotación
double xm=xp-OrignePixelsX;
double ym=yp-OrignePixelsY;
double zm=zp-OrignePixelsZ; // no se requiere pero para entender la cosa

// rotamos en sentido contrario al del las transformaciones de mundo a pixel
// hay que tener cuidado de usar las correctas "ALGEBRA LINEAL" []trans
x = ( /*funciones de desrotacion*/ );
y = ( /*funciones de desrotacion*/ );
z = ( /*funciones de desrotacion*/ );

//escalamos y trasladamos
x=(x+OrigneX)/EscalaX;
y=(y+OrigneY)/EscalaY;
z=(z+OrigneZ)/EscalaZ;
}

// espero que esto te ayude suerte Tin0 (tin0@tutopia.com)

[Gabriel]

La verdad que me sirvio, muchas gracias