c++ - library - instalar libpng
¿Cómo leo los píxeles JPEG y PNG en C++ en Linux? (9)
Estoy procesando algunas imágenes y me gustaría leer individualmente cada valor de píxel en imágenes JPEG y PNG.
En mi escenario de implementación, sería incómodo para mí usar una biblioteca de terceros (ya que tengo acceso restringido en el equipo de destino), pero supongo que no hay una biblioteca estándar de C o C ++ para leer JPEG / PNG ...
Entonces, si conoces una manera de no usar una biblioteca, entonces, ¡si no, entonces las respuestas son bienvenidas!
Como podría usar la exposición, mencionaré otra biblioteca para investigar: el Kit de herramientas de IM , que se encuentra en Sourceforge . Es multiplataforma y extrae el formato de archivo completamente lejos del usuario, lo que permite que una imagen se cargue y se procese sin preocuparse por la mayoría de los detalles. Admite PNG y JPEG de forma inmediata, y puede ampliarse con otros filtros de importación si es necesario.
Viene con una gran colección de operadores de procesamiento de imágenes, así como ...
También tiene un enlace de buena calidad a Lua .
Como señaló Nils, no existe una biblioteca estándar C o C ++ para la compresión JPEG y la manipulación de imágenes.
En caso de que pueda utilizar una biblioteca de terceros, es posible que desee probar GDAL que admite JPEG, PNG y decenas de otros formatos, compresiones y medios.
Este es un ejemplo simple que presenta cómo leer datos de píxeles de un archivo JPEG utilizando la API de GDAL C ++:
#include <gdal_priv.h>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
int main()
{
GDALAllRegister(); // once per application
// Assume 3-band image with 8-bit per pixel per channel (24-bit depth)
std::string const file("/home/mloskot/test.jpg");
// Open file with image data
GDALDataset* ds = static_cast<GDALDataset*>(GDALOpen(file.c_str(), GA_ReadOnly));
assert(0 != ds);
// Example 1 - Read multiple bands at once, assume 8-bit depth per band
{
int const ncols = ds->GetRasterXSize();
int const nrows = ds->GetRasterYSize();
int const nbands = ds->GetRasterCount();
int const nbpp = GDALGetDataTypeSize(GDT_Byte) / 8;
std::vector<unsigned char> data(ncols * nrows * nbands * nbpp);
CPLErr err = ds->RasterIO(GF_Read, 0, 0, ncols, nrows, &data[0], ncols, nrows, GDT_Byte, nbands, 0, 0, 0, 0);
assert(CE_None == err);
// ... use data
}
// Example 2 - Read first scanline by scanline of 1 band only, assume 8-bit depth per band
{
GDALRasterBand* band1 = ds->GetRasterBand(1);
assert(0 != band1);
int const ncols = band1->GetXSize();
int const nrows = band1->GetYSize();
int const nbpp = GDALGetDataTypeSize(GDT_Byte) / 8;
std::vector<unsigned char> scanline(ncols * nbpp);
for (int i = 0; i < nrows; ++i)
{
CPLErr err = band1->RasterIO(GF_Read, 0, 0, ncols, 1, &scanline[0], ncols, 1, GDT_Byte, 0, 0);
assert(CE_None == err);
// ... use scanline
}
}
return 0;
}
Hay más tutorial completo de la API de GDAL disponible.
Desafortunadamente, el formato jpeg está comprimido, por lo que tendría que descomprimirlo antes de leer píxeles individuales. Esta es una tarea no trivial. Si no puede usar una biblioteca, puede consultar una para ver cómo está descomprimiendo la imagen. Hay una biblioteca de código abierto en sourceforge: CImg en sourceforge.
Esta es una pequeña rutina que extraje de un código fuente de 10 años (usando libjpeg):
#include <jpeglib.h>
int loadJpg(const char* Name) {
unsigned char a, r, g, b;
int width, height;
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE * infile; /* source file */
JSAMPARRAY pJpegBuffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
if ((infile = fopen(Name, "rb")) == NULL) {
fprintf(stderr, "can''t open %s/n", Name);
return 0;
}
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
jpeg_stdio_src(&cinfo, infile);
(void) jpeg_read_header(&cinfo, TRUE);
(void) jpeg_start_decompress(&cinfo);
width = cinfo.output_width;
height = cinfo.output_height;
unsigned char * pDummy = new unsigned char [width*height*4];
unsigned char * pTest = pDummy;
if (!pDummy) {
printf("NO MEM FOR JPEG CONVERT!/n");
return 0;
}
row_stride = width * cinfo.output_components;
pJpegBuffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
while (cinfo.output_scanline < cinfo.output_height) {
(void) jpeg_read_scanlines(&cinfo, pJpegBuffer, 1);
for (int x = 0; x < width; x++) {
a = 0; // alpha value is not supported on jpg
r = pJpegBuffer[0][cinfo.output_components * x];
if (cinfo.output_components > 2) {
g = pJpegBuffer[0][cinfo.output_components * x + 1];
b = pJpegBuffer[0][cinfo.output_components * x + 2];
} else {
g = r;
b = r;
}
*(pDummy++) = b;
*(pDummy++) = g;
*(pDummy++) = r;
*(pDummy++) = a;
}
}
fclose(infile);
(void) jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
BMap = (int*)pTest;
Height = height;
Width = width;
Depth = 32;
}
He tenido buenas experiencias con la biblioteca de DevIL . Admite una amplia gama de formatos de imagen y sigue un estilo de función muy similar a OpenGL.
Por supuesto, es una biblioteca, pero definitivamente vale la pena intentarlo.
No hay una biblioteca estándar en el estándar C para leer los formatos de archivo.
Sin embargo, la mayoría de los programas, especialmente en la plataforma Linux, usan la misma biblioteca para decodificar los formatos de imagen:
Para jpeg es libjpeg, para png es libpng.
Las posibilidades de que las librerías ya estén instaladas son muy altas.
Para jpeg, ya existe una biblioteca llamada libjpeg , y existe libpng para png. La buena noticia es que se compilan directamente y, por lo tanto, las máquinas de destino no necesitarán archivos dll ni nada. La mala noticia es que están en C :(
Además, ni siquiera pienses en intentar leer los archivos tú mismo. Si desea un formato fácil de leer, use PPM lugar.
Ya que las otras respuestas ya mencionan que lo más probable es que necesite usar una biblioteca, eche un vistazo a ImageMagick y vea si es posible hacer lo que necesita hacer. Viene con una variedad de formas diferentes de interactuar con la funcionalidad principal de ImageMagick, incluidas las bibliotecas para casi todos los lenguajes de programación disponibles.
Página de inicio: ImageMagick