Práctica 4 Luis Pablo Nieto Gil Transformaciones Geométricas

Centro de Enseñanza Técnica Industrial
Plantel Colomos
Ingeniería en Desarrollo de Software
Procesamiento de Imágenes
REPORTE DE PRÁCTICA
IDENTIFICACIÓN DE LA PRÁCTICA
Práctica 4 Nombre de la práctica Transformaciones geométricas

Fecha 05/01/22 Nombre del profesor Alma Nayeli Rodríguez Vázquez
Nombre del estudiante NIETO GIL LUIS PABLO
OBJETIVO
El objetivo de esta práctica consiste en realizar las diferentes transformaciones geométricas a una imagen
en escala de grises mediante las transformaciones afines.
PROCEDIMIENTO
Realiza la implementación siguiendo estas instrucciones.
Realiza un programa en C/C++ utilizando OpenCV en el que leas una imagen desde archivo utilizando el
modo IMREAD_GRAYSCALE. Realiza las siguientes transformaciones geométricas a la imagen en escala
de grises.
1. Escalamiento
2. Rotación
3. Traslación
4. Sesgado vertical
5. Sesgado horizontal
Reporta los resultados obtenidos.
IMPLEMENTACIÓN
Agrega el código de tu implementación aquí.
//Escalamiento
void escalar(Mat origen, Mat *destino, float fx, float fy) {
float T[3][3] = { {fx,0,0},{0,fy,0 },{0,0,1}};
int v, w;
uchar* pOrigen, *pDestino;
if (fx < 1 || fy < 1) {
destino->create((origen.rows * fx)+1, (origen.cols * fy)+1, origen.type());
}
else {
destino->create(origen.rows * fx, origen.cols * fy, origen.type());
}
for (int x = 0; x < origen.rows; x++) {
pOrigen = origen.ptr<uchar>(x);
for (int y = 0; y < origen.cols; y++) {

v = x * T[0][0] + y * T[1][0]+ 1*T[2][0];
w = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
pDestino = destino->ptr<uchar>(v);
pDestino[w] = pOrigen[y];
}
1
Plantel Colomos
}
}
//Rotacion fx cos sen, fy - sen cos

void rotacion(Mat origen, Mat* destino, double grados) {
double anguloRad = grados * (2*acos(0))/ 180;
double T[3][3] = { {cos(anguloRad), sin(anguloRad),0}, {-sin(anguloRad), cos(anguloRad),0}
,{0,0,1} };
int areaImegen= origen.rows*origen.cols;
//Direccionamiento dinamico para establecer la dimension de la imagen
int* v = (int*) malloc(areaImegen * sizeof(int));
int* w = (int*) malloc(areaImegen * sizeof(int));
uchar* pOrigen, * pDestino;
//Recorrido de la imagen
int k=0;
v[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
w[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}
//Evitar los numeros negativos
int* pMin_v = min_element(v, v + areaImegen);
int* pMin_w= min_element(w, w + areaImegen);
int min_v = *pMin_v;
int min_w = *pMin_w;
for (int i = 0; i < areaImegen; i++) {//evitar negativos
v[i] = v[i] - min_v;
w[i] = w[i] - min_w;
}
int* pMax_v = max_element(v, v + areaImegen);
int* pMax_w = max_element(w, w + areaImegen);
int max_v= *pMax_v;
int max_w = *pMax_w;
destino->create(max_v+1, max_w+1, origen.type()); //el 1 es para evitar errores de memoria
//Acomoda
k = 0;
//agregar en v w a destino
pDestino = destino->ptr<uchar>(v[k]);
pDestino[w[k]] = pOrigen[y];
k++;
}
}
free(w);
free(v);
}
//Rotacion
void algoritmoRotacion(Mat origen, Mat* destino, int grados) {
float T[3][3] = { {1,0,0},{0,1,0 },{0,0,1} };
int areaImegen = origen.rows * origen.cols;
int* v = (int*)malloc(areaImegen * sizeof(int));
int* w = (int*)malloc(areaImegen * sizeof(int));
2
Plantel Colomos
int k = 0;
if (grados ==-90) {
destino->create(origen.cols +1 ,origen.rows+1 , origen.type());
for (int x = origen.rows-1; x >=0; x--) {
for (int y = origen.cols - 1; y >= 0; y--) {
w[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
v[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}
}
else if (grados==90) {
destino->create(origen.cols + 1, origen.rows + 1, origen.type());
for (int x = 0; x <origen.rows; x++) {

for (int y = 0; y <origen.cols ; y++) {
w[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
v[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}
}
else if(grados==180 ) {
destino->create( origen.rows + 1, origen.cols + 1, origen.type());
for (int x = origen.rows - 1; x >= 0; x--) {
for (int y = origen.cols - 1; y >= 0; y--) {
v[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
w[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}
}
//Acomoda
k = 0;
k++;
}
}
free(w);
free(v);
}
//Traslacion
void traslacion(Mat origen, Mat* destino, int tx, int ty) {
int T[3][3] = { {1,0,0},{0,1,0 },{tx,ty,1} };
int v, w;
destino->create(origen.rows + tx, origen.cols + ty, origen.type());
3
Plantel Colomos

v = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
w = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
pDestino = destino->ptr<uchar>(v);
pDestino[w] = pOrigen[y];
}
}
}
//Sesgos
void sesgoVertical(Mat origen, Mat* destino, float Sv) {
float T[3][3] = { {1,0,0}, {Sv, 1,0} ,{0,0,1} };

int k = 0;
v[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
w[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}

int max_v = *pMax_v;
destino->create(max_v + 1, max_w + 1, origen.type()); //el 1 es para evitar errores de memoria

k = 0;
k++;
}
}
free(w);
free(v);
}
void sesgoHorizontal(Mat origen, Mat* destino, float Sv) {

float T[3][3] = { {1,Sv,0}, {0, 1,0} ,{0,0,1} };
4
Plantel Colomos
int k = 0;
v[k] = x * T[0][0] + y * T[1][0] + 1 * T[2][0];
w[k] = x * T[0][1] + y * T[1][1] + 1 * T[2][1];
k++;
}
}
int max_v = *pMax_v;
destino->create(max_v + 1, max_w + 1, origen.type()); //el 1 es para evitar errores de memoria
k = 0;
k++;
}
}
free(w);
free(v);
}
int main()
{
Mat imagen = imread("scream.jpg", IMREAD_GRAYSCALE);
imshow("img", imagen);
Mat imagenEscalada;
escalar(imagen, &imagenEscalada, 0.4, 0.8);//Escalamiento al 50%
imshow("img escalada 0.4 x 0.8", imagenEscalada);
escalar(imagen, &imagenEscalada, 0.5, 0.5);
imshow("img escalada 0.5 x 0.5", imagenEscalada);
Mat imagenRotacion;
rotacion(imagen,&imagenRotacion , 45.00);
imshow("img rotada 45", imagenRotacion);
rotacion(imagen, &imagenRotacion, -45.00);
imshow("img rotada -45", imagenRotacion);
rotacion(imagen, &imagenRotacion, 15.00);
imshow("img rotada 15", imagenRotacion);
rotacion(imagen, &imagenRotacion, -15.00);
imshow("img rotada -15", imagenRotacion);
Mat imgRotacionAlgotimo;
algoritmoRotacion(imagen, &imgRotacionAlgotimo, 90);
imshow("imagen algoritmo rotada 90", imgRotacionAlgotimo);
algoritmoRotacion(imagen, &imgRotacionAlgotimo, -90);
imshow("imagen algoritmo rotada -90", imgRotacionAlgotimo);
algoritmoRotacion(imagen, &imgRotacionAlgotimo, 180);
imshow("imagen algoritmo rotada 180", imgRotacionAlgotimo);
Mat imagenTraslacion;
5
Plantel Colomos
traslacion(imagen, &imagenTraslacion, 50, 50);
imshow("imagen trasladada 50 y 50", imagenTraslacion);
traslacion(imagen, &imagenTraslacion, 50, 100);
imshow("imagen trasladada 50 y 100", imagenTraslacion);
Mat imgVerticalSesgo;
sesgoVertical(imagen, &imgVerticalSesgo, 1);
imshow("imagensesgada vertical 1", imgVerticalSesgo);
sesgoVertical(imagen, &imgVerticalSesgo, 0.5);
imshow("imagensesgada vertical 0.5", imgVerticalSesgo);
Mat imgHorizontalSesgo;
sesgoHorizontal(imagen, &imgHorizontalSesgo, 1);
imshow("imagensesgada horizontal 1", imgHorizontalSesgo);
sesgoHorizontal(imagen, &imgHorizontalSesgo, 0.5);
imshow("imagensesgada horizontal 0.5", imgHorizontalSesgo);
Mat imgSesgoEscalada;
escalar(imgVerticalSesgo, &imgSesgoEscalada, 2, 2);//Escalamiento al 50%
imshow("img Escalada Con Sesgo", imgSesgoEscalada);
waitKey(0);
}
RESULTADOS
Agrega las imágenes indicadas en los espacios correspondientes.
Imagen en escala Escalamiento Escalamiento Rotación

de grises cx = 0.4 y cy =0.8 cx = 0.5 y cy = 0.5 45 grados
6
Plantel Colomos
Rotación Rotación Rotación Rotación 2
-45 grados 15 grados -15 grados 180 grados
Rotación 2 Rotación 2 Traslación Traslación

90 grados -90 grados tx = 50 y ty = 50 tx = 50 y ty = 100
Sesgado vertical Sesgado vertical Sesgado horizontal Sesgado horizontal

sv = 1 sv = 0.5 sh = 1 sh = 0.5
7
Plantel Colomos
Escalamiento (coloca la imagen en tamaño original)

cx = 2 y cy =2
8
Plantel Colomos
CONCLUSIONES
Escribe tus observaciones y conclusiones.
En esta práctica realizamos ejemplos donde podemos apreciar las transformaciones geométricas de una imagen.
Como se ve en los ejemplos la imagen se puede llegar a distorsionar la imagen, ya que los pixeles se ven mas
detallados, ósea se logra ver el recuadro del pixel. Esto puede ser muy útil para ver el funcionamiento de las
herramientas mas actuales en nuestras aplicaciones de edición de imágenes.

Práctica 4 Luis Pablo Nieto Gil Transformaciones Geométricas

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Práctica 4 Luis Pablo Nieto Gil Transformaciones Geométricas

Cargado por

Copyright:

Formatos disponibles

Centro de Enseñanza Técnica Industrial

Práctica 4 Nombre de la práctica Transformaciones geométricas

for (int y = 0; y < origen.cols; y++) {

//Rotacion fx cos sen, fy - sen cos

for (int x = 0; x <origen.rows; x++) {

for (int y = 0; y < origen.cols; y++) {

float T[3][3] = { {1,0,0}, {Sv, 1,0} ,{0,0,1} };

int areaImegen = origen.rows * origen.cols;

int* v = (int)malloc(areaImegen sizeof(int));

uchar* pOrigen, * pDestino;

int* pMax_v = max_element(v, v + areaImegen);

destino->create(max_v + 1, max_w + 1, origen.type()); //el 1 es para evitar errores de memoria

void sesgoHorizontal(Mat origen, Mat* destino, float Sv) {

Imagen en escala Escalamiento Escalamiento Rotación

Rotación 2 Rotación 2 Traslación Traslación

Sesgado vertical Sesgado vertical Sesgado horizontal Sesgado horizontal

Escalamiento (coloca la imagen en tamaño original)

También podría gustarte