Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » necesito hacer este programa

C/Visual C - necesito hacer este programa

Volver
Nuevo Tema
<<>>
 
Vista:

necesito hacer este programa

Publicado por Raul (2 intervenciones) el 25/07/2002 20:36:28
IMÁGENES

Tienes una importante compañía de diseño gráfico por computadora la cual ha realizado importantes trabajos de computación a películas como “ritanic”, “microbios”, y muchas mas que seguramente fueron éxitos. Tu fama se debe a que tu compañía es la única que trabaja con el trabajo de imágenes digitales por computadora usando una técnica muy especial que pocos “profesionales conocen”.

Has llegado a tal fama que una gran empresa internacional de origen mexicano te ha solicitado tus servicios. El trabajo consiste en lo siguiente:

Se tiene una imagen digital de dimensión n por m (renglones, columnas). Esta imagen tiene variaciones de hasta 128 colores. Las imágenes son fotografías de mapas que van a ser usados en la película. Estos contienen figuras que tu deberás de identificar dado un rango determinado de colores que pude varias entre un intervalo h1 y h2 (ie: h1 h2 siempre) donde 0 127 y k es el color admisible en la figura. Una vez identificadas todas las figuras deberás exhibir los siguientes mapas: un mapa binario (0’s y 1’s) que represente con unos el área de todas las figuras que se identificaron en el mapa original (a esta técnica se le llama binarización. Un mapa binario (0’s y 1’s) que muestre únicamente los contornos de las figuras representando con unos el contorno y con ceros cualquier otra información.. Y como última tarea, al final del archivo deberás de escribir el número de figuras encontradas y el área de la figura más grande.

ENTRADA
La entrada consiste en un archivo de texto que contiene en la primer fila dos números: n y m, que denotan las dimensiones de la imagen.
A continuación se presenta la matriz de números que representa a la imagen digital.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Programa para procesar imágenes digitales

Publicado por Alejandro (913 intervenciones) el 11/03/2025 19:27:07
Descripción del programa:
El programa procesará una imagen digital representada como una matriz de colores (valores entre 0 y 127). Identificará figuras dentro de un rango de colores especificado, generará un mapa binario que represente las figuras y otro que muestre solo los contornos. Además, contará el número de figuras encontradas y determinará el área de la figura más grande.

Estructura del programa:

1. Leer la entrada desde un archivo.
2. Identificar las figuras basadas en el rango de colores.
3. Generar el mapa binario de las figuras.
4. Generar el mapa de contornos.
5. Contar el número de figuras y calcular el área de la figura más grande.
6. Escribir los resultados en un archivo de salida.

Código de ejemplo:

Aquí tienes un ejemplo básico de cómo podría ser el código en C:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include <stdio.h>
#include <stdlib.h>
 
#define MAX_COLORS 128
 
// Estructura para almacenar la imagen
typedef struct {
    int **data;
    int rows;
    int cols;
} Image;
 
// Función para crear una imagen
Image createImage(int rows, int cols) {
    Image img;
    img.rows = rows;
    img.cols = cols;
    img.data = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        img.data[i] = (int *)malloc(cols * sizeof(int));
    }
    return img;
}
 
// Función para liberar la memoria de la imagen
void freeImage(Image img) {
    for (int i = 0; i < img.rows; i++) {
        free(img.data[i]);
    }
    free(img.data);
}
 
// Función para leer la imagen desde un archivo
Image readImage(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (!file) {
        perror("No se puede abrir el archivo");
        exit(EXIT_FAILURE);
    }
 
    int n, m;
    fscanf(file, "%d %d", &n, &m);
    Image img = createImage(n, m);
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            fscanf(file, "%d", &img.data[i][j]);
        }
    }
 
    fclose(file);
    return img;
}
 
// Función para generar el mapa binario
Image generateBinaryMap(Image img, int h1, int h2) {
    Image binaryMap =createImage(img.rows, img.cols);
    for (int i = 0; i < img.rows; i++) {
        for (int j = 0; j < img.cols; j++) {
            binaryMap.data[i][j] = (img.data[i][j] >= h1 && img.data[i][j] <= h2) ? 1 : 0;
        }
    }
    return binaryMap;
}
 
// Función para generar el mapa de contornos
Image generateContourMap(Image img) {
    Image contourMap = createImage(img.rows, img.cols);
    for (int i = 0; i < img.rows; i++) {
        for (int j = 0; j < img.cols; j++) {
            contourMap.data[i][j] = 0; // Inicializar a 0
            if (img.data[i][j] == 1) { // Si es parte de una figura
                // Verificar contornos
                if (i == 0 || j == 0 || i == img.rows - 1 || j == img.cols - 1 ||
                    img.data[i-1][j] == 0 || img.data[i+1][j] == 0 ||
                    img.data[i][j-1] == 0 || img.data[i][j+1] == 0) {
                    contourMap.data[i][j] = 1; // Es contorno
                }
            }
        }
    }
    return contourMap;
}
 
// Función para contar figuras y encontrar el área de la figura más grande
void countFigures(Image binaryMap, int *numFigures, int *maxArea) {
    int visited[binaryMap.rows][binaryMap.cols];
    for (int i = 0; i < binaryMap.rows; i++) {
        for (int j = 0; j < binaryMap.cols; j++) {
            visited[i][j] = 0; // Inicializar a no visitado
        }
    }
 
    *numFigures = 0;
    *maxArea = 0;
 
    for (int i = 0; i < binaryMap.rows; i++) {
        for (int j = 0; j < binaryMap.cols; j++) {
            if (binaryMap.data[i][j] == 1 && !visited[i][j]) {
                // Encontrar el área de la figura
                int area = 0;
                // Realizar DFS o BFS para contar el área
                // (Implementar la lógica de búsqueda aquí)
                (*numFigures)++;
                if (area > *maxArea) {
                    *maxArea = area;
                }
            }
        }
    }
}
 
int main() {
    const char *inputFile = "imagen.txt"; // Archivo de entrada
    const char *outputFile = "resultados.txt"; // Archivo de salida
    int h1 = 20, h2 = 100; // Rango de colores
 
    Image img = readImage(inputFile);
    Image binaryMap = generateBinaryMap(img, h1, h2);
    Image contourMap = generateContourMap(binaryMap);
 
    int numFigures, maxArea;
    countFigures(binaryMap, &numFigures, &maxArea);
 
    // Escribir resultados en el archivo de salida
    FILE *outFile = fopen(outputFile, "w");
    fprintf(outFile, "Número de figuras: %d\n", numFigures);
    fprintf(outFile, "Área de la figura más grande: %d\n", maxArea);
    fclose(outFile);
 
    // Liberar memoria
    freeImage(img);
    freeImage(binaryMap);
    freeImage(contourMap);
 
    return 0;
}

Instrucciones para compilar y ejecutar:



1. Guarda el código en un archivo llamado `procesar_imagen.c`.
2. Crea un archivo de texto llamado `imagen.txt` con el formato especificado (dimensiones y matriz de colores).
3. Abre una terminal y navega al directorio donde guardaste el archivo.
4. Compila el código usando el siguiente comando:
1
gcc procesar_imagen.c -o procesar_imagen
5. Ejecuta el programa:
1
./procesar_imagen

Consideraciones adicionales:



- La función `countFigures` necesita implementar la lógica de búsqueda (DFS o BFS) para contar el área de cada figura. Esto se puede hacer utilizando una pila o una cola.
- Asegúrate de manejar adecuadamente la memoria y los errores de archivo.
- Puedes expandir el programa para incluir más características, como la visualización de los mapas generados.

Este código proporciona una base para el procesamiento de imágenes digitales según los requisitos especificados. ¡Buena suerte con tu proyecto!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar