C/Visual C - Importar imagenes a C

 
Vista:

Importar imagenes a C

Publicado por Esdichi (3 intervenciones) el 14/02/2003 14:32:47
Buenas mi pregunta es si existe un programa o en su defecto una forma de hacer que una imagene bmp hecha en el paint se pueda conventir en c.
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

Cómo convertir una imagen BMP a un array en C

Publicado por Alejandro (1153 intervenciones) el 05/05/2025 20:37:25
Sí, existen varias formas de convertir una imagen BMP creada en Paint a un formato que puedas utilizar en C. Aquí te presento algunas opciones:

1. Herramientas en línea



Hay herramientas en línea que te permiten cargar una imagen BMP y obtener el código C correspondiente. Estas herramientas convierten la imagen en un array de bytes que puedes incluir en tu código. Aquí hay un par de ejemplos:

- FileToCArray: Esta herramienta permite convertir imágenes a arrays en C. Puedes ajustar el formato de salida (Hex, Decimal, Binary) y optimizar la salida para diferentes modos de lectura. Puedes encontrarla en FileToCArray (https://notisrac.github.io/FileToCArray/).

- image_to_c: Este es un software que convierte varios formatos de imagen, incluyendo BMP, a arrays de código fuente en C. Puedes encontrarlo en image_to_c en GitHub (https://github.com/bitbank2/image_to_c).

2. Usar un script o programa personalizado



Si prefieres hacerlo tú mismo, puedes escribir un programa en C que lea un archivo BMP y lo convierta a un array. Aquí tienes un ejemplo básico de cómo podrías hacerlo:

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
#include <stdio.h>
#include <stdlib.h>
 
#pragma pack(push, 1) // Alinear la estructura
typedef struct {
    unsigned short bfType;      // Tipo de archivo
    unsigned int bfSize;        // Tamaño del archivo
    unsigned short bfReserved1; // Reservado
    unsigned short bfReserved2; // Reservado
    unsigned int bfOffBits;     // Offset a los datos de la imagen
} BITMAPFILEHEADER;
 
typedef struct {
    unsigned int biSize;          // Tamaño de la estructura
    int biWidth;                  // Ancho de la imagen
    int biHeight;                 // Alto de la imagen
    unsigned short biPlanes;      // Planos de color
    unsigned short biBitCount;    // Bits por pixel
    unsigned int biCompression;    // Compresión
    unsigned int biSizeImage;     // Tamaño de la imagen
    int biXPelsPerMeter;          // Resolución horizontal
    int biYPelsPerMeter;          // Resolución vertical
    unsigned int biClrUsed;       // Colores utilizados
    unsigned int biClrImportant;   // Colores importantes
} BITMAPINFOHEADER;
#pragma pack(pop)
 
void convertirBMPaC(const char* nombreArchivo) {
    FILE* archivo = fopen(nombreArchivo, "rb");
    if (!archivo) {
        printf("No se pudo abrir el archivo.\n");
        return;
    }
 
    BITMAPFILEHEADER bfh;
    fread(&bfh, sizeof(BITMAPFILEHEADER), 1, archivo);
 
    BITMAPINFOHEADER bih;
    fread(&bih, sizeof(BITMAPINFOHEADER), 1, archivo);
 
    // Leer los datos de la imagen
    int tamanoImagen = bih.biWidth * bih.biHeight * (bih.biBitCount / 8);
    unsigned char* datos = (unsigned char*)malloc(tamanoImagen);
    fseek(archivo, bfh.bfOffBits, SEEK_SET);
    fread(datos, tamanoImagen, 1, archivo);
    fclose(archivo);
 
    // Imprimir el array en formato C
    printf("unsigned char imagen[%d][%d][3] = {\n", bih.biHeight, bih.biWidth);
    for (int i = 0; i < bih.biHeight; i++) {
        printf("    {");
        for (int j = 0; j < bih.biWidth; j++) {
            int index = (i * bih.biWidth + j) * (bih.biBitCount / 8);
            printf("{%d, %d, %d}", datos[index + 2], datos[index + 1], datos[index]); // RGB
            if (j < bih.biWidth - 1) printf(", ");
        }
        printf("}");
        if (i < bih.biHeight - 1) printf(",\n");
    }
    printf("\n};\n");
 
    free(datos);
}
 
int main() {
    convertirBMPaC("tu_imagen.bmp"); // Cambia "tu_imagen.bmp" por el nombre de tu archivo
    return 0;
}

3. Usar bibliotecas



Si prefieres no lidiar con la conversión manual, puedes usar bibliotecas que manejan imágenes y te permiten cargar BMP y convertirlas a arrays en C. Algunas bibliotecas populares son:

- stb_image: Una biblioteca de una sola cabecera que permite cargar imágenes en varios formatos, incluyendo BMP. Puedes encontrarla en stb_image.h (https://github.com/nothings/stb/blob/master/stb_image.h).

Conclusión



Existen múltiples formas de convertir una imagen BMP a un formato que puedas usar en C. Puedes optar por herramientas en línea, escribir tu propio programa o utilizar bibliotecas existentes. Escoge la opción que mejor se adapte a tus necesidades y habilidades. ¡Buena suerte, Esdichi!
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