Las transformaciones juegan un papel muy importante en la manipulación de objetos en la pantalla. Cabe señalar que aquí los algoritmos se implementarán en el código y las funciones integradas no se utilizarán para dar una buena comprensión de cómo funcionan los algoritmos. Además, tenga en cuenta que todas las transformaciones se implementan en 2D . Hay tres tipos básicos de transformaciones en gráficos por computadora: 1. Traslación 2. Rotación 3. Escalado
Algoritmos:
1. Traducción: la traducción se refiere a mover un objeto a una posición diferente en la pantalla.
Formula: X = x + tx
Y = y + ty
where tx and ty are translation coordinates
The OpenGL function is glTranslatef( tx, ty, tz );
2. Rotación: Rotación se refiere a rotar un punto.
Formula: X = xcosA - ysinA
Y = xsinA + ycosA,
A is the angle of rotation.
The above formula will rotate the point around the origin.
To rotate around a different point, the formula:
X = cx + (x-cx)*cosA - (y-cy)*sinA,
Y = cy + (x-cx)*sinA + (y-cy)*cosA,
cx, cy is centre coordinates,
A is the angle of rotation.
The OpenGL function is glRotatef (A, x, y, z).
3. Escalado: el escalado se refiere a acercar y alejar un objeto en diferentes escalas a lo largo de los ejes.
Formula: X = x*sx
Y = y*sy, sx, sy being scaling factors.
The OpenGL function is glScalef(float x, float y, float z)
Nota: Si se van a aplicar transformaciones combinadas, siga el orden: traducir, rotar, escalar
Implementación:
C
// C code to implement basic
// transformations in OPENGL
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <GL/glut.h>
// Window size
#define maxWD 640
#define maxHT 480
// Rotation speed
#define thetaSpeed 0.05
// This creates delay between
// two actions
void delay(unsigned int mseconds)
{
clock_t goal = mseconds + clock();
while (goal > clock());
}
// This is a basic init for the
// glut window
void myInit(void)
{
glClearColor(1.0, 1.0,
1.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, maxWD,
0.0, maxHT);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}
// This function just draws
// a point
void drawPoint(int x, int y)
{
glPointSize(7.0);
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
void rotateAroundPt(int px, int py,
int cx, int cy)
{
float theta = 0.0;
while (1)
{
glClear(GL_COLOR_BUFFER_BIT);
int xf, yf;
// Update theta anticlockwise
// rotation
theta = theta + thetaSpeed;
// Check overflow
if (theta>= (2.0 * 3.14159))
theta = theta - (2.0 * 3.14159);
// actual calculations..
xf = (cx + (int)((float)(px - cx) *
cos(theta)) - ((float)(py - cy) *
sin(theta)));
yf = (cy + (int)((float)(px - cx) *
sin(theta)) + ((float)(py - cy) *
cos(theta)));
// Drawing the centre point
drawPoint(cx, cy);
// Drawing the rotating point
drawPoint(xf, yf);
glFlush();
// Creating a delay
// So that the point can be noticed
delay(10);
}
}
// This function will translate
// the point
void translatePoint(int px, int py,
int tx, int ty)
{
int fx = px, fy = py;
while (1)
{
glClear(GL_COLOR_BUFFER_BIT);
// Update
px = px + tx;
py = py + ty;
// Check overflow to keep
// point in screen
if (px > maxWD || px < 0 ||
py > maxHT || py < 0)
{
px = fx;
py = fy;
}
// Drawing the point
drawPoint(px, py);
glFlush();
// Creating a delay
// So that the point can be noticed
delay(10);
}
}
// This function draws
void scalePoint(int px, int py,
int sx, int sy)
{
int fx, fy;
while (1)
{
glClear(GL_COLOR_BUFFER_BIT);
// Update
fx = px * sx;
fy = py * sy;
// Drawing the point
drawPoint(fx, fy);
glFlush();
// Creating a delay
// So that the point can
// be noticed
delay(500);
glClear(GL_COLOR_BUFFER_BIT);
// Update
fx = px;
fy = py;
// Drawing the point
drawPoint(fx, fy);
glFlush();
// Creating a delay
// So that the point can be
// noticed
delay(500);
}
}
// Actual display function
void myDisplay(void)
{
int opt;
printf("\nEnter\n\t<1> for translation"
"\n\t<2> for rotation"
"\n\t<3> for scaling\n\t:");
scanf("%d", &opt);
printf("\nGo to the window...");
switch (opt){
case 1:
translatePoint(100, 200, 1, 5);
break;
case 2:
rotateAroundPt(200, 200, maxWD / 2,
maxHT / 2);
// Point will circle around
// the centre of the window
break;
case 3:
scalePoint(10, 20, 2, 3);
break;
}
}
// Driver code
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(maxWD, maxHT);
glutInitWindowPosition(100, 150);
glutCreateWindow("Transforming point");
glutDisplayFunc(myDisplay);
myInit();
glutMainLoop();
}
Este artículo es una contribución de Suprotik Dey . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA