¿Cómo leer los datos de una imagen en VC? ¿Cómo escribir el programa específico? Por ejemplo, imágenes JPEG

Proporcionarle una clase para leer bmp, la clase ImgCenterDib

Utilice la función BOOL ImgCenterDib::Read(LPCTSTR lpszPathName). Puede estudiar esto usted mismo específicamente. él.

De hecho, es incorrecto decir que vc6 solo puede leer bmp. También leo jpeg y otros formatos en vc6. Si es necesario, puedo publicarlo.

// archivo .h

#define _INSIDE_VISUAL_CPP_IMGCENTERDIB

//Clase ImgCenterDib, centro de procesamiento de imágenes, clase DIB escrita por Beihang Image Center

//Clase ImgCenterDib

clase ImgCenterDib

{

public:

//Puntero de datos de imagen

unsigned char * m_pImgData <; /p>

//Puntero de la tabla de colores de la imagen

LPRGBQUAD m_lpColorTable

//Número de bits por píxel

int m_nBitCount

// Puntero a DIB (incluidos BITMAPFILEHEADER, BITMAPINFOHEADER y tabla de colores)

LPBYTE m_lpDib;

privado:

//Puntero de encabezado de información de imagen

LPBITMAPINFOHEADER m_lpBmpInfoHead;

//Manejador de paleta

HPALETTE m_hPalette

//Longitud de la tabla de colores

int; m_nColorTableLength;

public:

//Constructor sin parámetros

ImgCenterDib();

//Constructor con parámetros

ImgCenterDib(CSize size, int nBitCount, LPRGBQUAD lpColorTable, unsigned char *pImgData);

//Destructor

~ImgCenterDib();

/ /Función de lectura DIB

BOOL Read(LPCTSTR lpszPathName);

//Función de escritura DIB

BOOL Write(LPCTSTR lpszPathName);

//Función de visualización DIB

BOOL Draw(CDC* pDC, CPoint origin, CSize size

//Función de generación de paleta lógica

void MakePalette(); );

//Obtener el tamaño del DIB (ancho y alto)

CSize GetDimensions();

//Borrar espacio

void Vacuum();

//Reemplazar el DIB actual con datos nuevos

void ReemplazoDib(CSize size, int nBitCount, LPRGBQUAD lpColorTable,

unsigned char *pImgData);

//Calcula la longitud de la tabla de colores

int ComputeColorTabalLeng

th(int nBitCount);

protected:

//El ancho de la imagen en píxeles

int m_imgWidth;

// La altura de la imagen en píxeles

int m_imgHeight

}

#endif // _INSIDE_VISUAL_CPP_IMGCENTERDIB

///// ////////////////////////////////////////////////// /// ///

//archivo cpp

#include "stdafx.h"

#include "ImageCenterDib.h"

# ifdef _DEBUG

#define new DEBUG_NEW

#undef ESTE_FILE

carácter estático ESTE_FILE[] = __FILE__;

#endif

/****************************************** ****** ****************************

* Nombre de la función:

* ImgCenterDib()

*

*Descripción: Constructor sin parámetros, inicializa variables miembro

************ ****** ********************************************** ******* *****/

ImgCenterDib::ImgCenterDib()

{

m_lpDib=NULL //Inicializa m_lpDib en estar vacío.

m_lpColorTable=NULL; //El puntero de la tabla de colores es NULL

m_pImgData=NULL //El puntero de datos de la imagen es NULL

m_lpBmpInfoHead=NULL; /Imagen El puntero del encabezado de información es NULL

m_hPalette = NULL //La paleta está vacía

}

/********* ** ************************************************* *** **********

* Nombre de la función:

* ImgCenterDib()

*Parámetros de función:

* Tamaño CSize - tamaño de la imagen (ancho, alto)

* int nBitCount - número de bits por píxel

* LPRGBQUAD lpColorTable - color puntero de tabla

* carácter sin firmar *pImgData - puntero de datos de mapa de bits

*

*Valor de retorno:

* Ninguno

*

*Explicación: Esta función es un constructor con parámetros, dado el tamaño del mapa de bits, número de bits por píxel, tabla de colores

* y datos del mapa de bits y otros información, Crear un objeto de la clase ImgCenterDib

************************************ ******** **********************************/

ImgCenterDib ::ImgCenterDib(CSize size, int nBitCount, LPRGBQUAD lpColorTable,

unsigned char *pImgData)

{

//Si no se pasan datos de mapa de bits, creemos que es un DIB vacío, esto No asigna memoria DIB

if(pImgData==NULL){

m_lpDib=NULL

m_lpColorTable=NULL;

m_pImgData =NULL

m_lpBmpInfoHead=NULL

m_hPalette = NULL

}

{//Si se transmiten datos de mapa de bits Ingrese

//Asignación de variables miembro como ancho, alto y número de bits por píxel de la imagen

m_imgWidth=size.cx;

m_imgHeight=size.cy;

m_nBitCount=nBitCount;

//Calcula la longitud de la tabla de colores en función del número de bits por píxel

m_nColorTableLength=ComputeColorTabalLength(nBitCount);

//El número de bytes ocupados por cada fila de píxeles debe expandirse a un múltiplo de 4

int lineByte=(m_imgWidth *nBitCount/8 3)/4*4;

// El tamaño del búfer de datos de mapa de bits (tamaño de imagen)

int imgBufSize=m_imgHeight*lineByte;

//Asigna memoria una vez para m_lpDib

, generar estructura DIB

m_lpDib=new BYTE [sizeof(BITMAPINFOHEADER)

sizeof(RGBQUAD) * m_nColorTableLength imgBufSize];

//Completa la estructura BITMAPINFOHEADER

m_lpBmpInfoHead = (LPBITMAPINFOHEADER) m_lpDib;

m_lpBmpInfoHead-gt; biSize = m_imgWidth; /p>

m_lpBmpInfoHead-gt; biHeight = m_imgHeight;

m_lpBmpInfoHead-gt; biPlanes = 1

m_lpBmpInfoHead-gt; > m_lpBmpInfoHead-gt; biCompression = BI_RGB;

m_lpBmpInfoHead-gt; biSizeImage = 0

m_lpBmpInfoHead-gt; biYPelsPerMeter = 0;

m_lpBmpInfoHead-gt; biClrUsed = m_nColorTableLength;

m_lpBmpInfoHead-gt; y hay una tabla de colores Cuando, la función MakePalette() crea una nueva paleta lógica

m_hPalette = NULL;

if(m_nColorTableLength!=0){ //Si hay una tabla de colores, el color La tabla se copia en la posición de la tabla de colores del DIB

//Use m_lpColorTable para señalar la posición inicial de la tabla de colores DIB

m_lpColorTable=(LPRGBQUAD )(m_lpDib sizeof(BITMAPINFOHEADER));

//Copia de la tabla de colores

memcpy(m_lpColorTable, lpColorTable,

sizeof(RGBQUAD) * m_nColorTableLength); /p>

//Crea un tablero para colorear lógico

MakePalette();

}

//Utiliza m_pImgData para señalar la posición inicial de DIB datos de mapa de bits

m_pImgData = (LPBYTE )m_lpDib sizeof(BITMAPINFOHEADER)

sizeof(RGBQUAD) * m_nColorTableLength

//Copie los datos de la imagen en el mapa de bits DIB; área de datos

memcpy(m_pIm

gData, pImgData, imgBufSize

}

}

/********************* *** ************************************************* **** **

* Nombre de la función:

* ~ImgCenterDib()

*

* Descripción: Destructor, lanzamientos recursos

****************************************** ****** ****************************/

ImgCenterDib::~ImgCenterDib()

{

//Libera el búfer de memoria señalado por m_lpDib

if(m_lpDib != NULL)

eliminar [] m_lpDib <; /p>

//Si hay una paleta, suelte la paleta

if(m_hPalette != NULL)

::DeleteObject(m_hPalette);

}

/*************************************** ********* ****************************

* Nombre de la función:

* Draw()

*

*Parámetros de función:

* CDC* pDC - puntero de contexto del dispositivo

* COrigen del punto: la esquina superior izquierda del área rectangular de visualización

* Tamaño CSize: el tamaño del área rectangular mostrada

*

*Valor de retorno:

* 0 para error, 1 para éxito

*

*Descripción: dado el puntero de entorno del dispositivo y la ubicación del área rectangular que se mostrará en el dispositivo entorno

* Establece el DIB al que apunta m_lpDib Muéstralo

*************************** *********************** **************************** ***/

BOOL ImgCenterDib::Draw(CDC* pDC, CPoint origin , CSize size)

{

//Antiguo identificador de paleta

HPALETTE hOldPal=NULL;

//Si DIB Si está vacío, devuelve 0

if(m_lpDib == NULL) devuelve FALSE;

//Si el DIB tiene una paleta, selecciónela en el entorno del dispositivo

if(m_hPalette != NULL) {

hOldPal=：:SelectPalette(pDC-gt; GetSafeHdc( ), m_hPalette, TRUE);

}

//Establecer el modo de extensión del mapa de bits

pDC-gt; p> //Muestra el DIB en el dispositivo señalado por pDC

:: StretchDIBits(pDC-gt; GetSafeHdc(), origin.x, orig

in.y, size.cx, size.cy,

0, 0, m_lpBmpInfoHead-gt; biWidth, m_lpBmpInfoHead-gt; biHeight, m_pImgData,

(LPBITMAPINFO)m_lpBmpInfoHead, DIB_RGB_COLORS , SRCCOPY);

//Restaurar la paleta anterior

if(hOldPal!=NULL)

:: SelectPalette(pDC-gt; GetSafeHdc( ), hOldPal, TRUE);

//La función devuelve

return TRUE;

}

/****** ** ************************************************* * **************

* Nombre de la función:

* Leer()

*

*Parámetros de función:

* LPCTSTR lpszPathName - nombre de archivo y ruta

*

*Valor de retorno:

* 0 es error , 1 es éxito

*

* Descripción: dado el nombre de un archivo de imagen y su ruta, asigne memoria, lea los datos de la imagen en la memoria para generar un DIB,

* y almacenado en el búfer señalado por m_lpDib

****************************** ****** *******************************************/

BOOL ImgCenterDib :: Read(LPCTSTR lpszPathName)

{

//Abrir archivo de imagen en modo lectura

Archivo CFile;

if (!file .Open(lpszPathName, CFile::modeRead | CFile::shareDenyWrite))

return FALSE;

BITMAPFILEHEADER bmfh;

try {

//Limpiar espacio

Vacuum();

//Leer la estructura BITMAPFILEHEADER en la variable bmfh

int nCount=file.Read((LPVOID )amp; bmfh, sizeof(BITMAPFILEHEADER));

//Sentencia de excepción

if(nCount != sizeof(BITMAPFILEHEADER)) {

lanzar nueva CException ;

}

if(bmfh.bfType != 0x4d42) {

lanzar nueva CException;

}

//Asignar espacio para m_lpDib y leer DIB en la memoria

if(m_lpDib!=NULL)

eliminar []m_lpDib;

m_lpDib=nuevo BYTE[archivo.GetLength() -sizeof(BITMA

PFILEHEADER)];

file.Read(m_lpDib, file.GetLength() -sizeof(BITMAPFILEHEADER));

//La posición de m_lpBmpInfoHead es la posición inicial de m_lpDib

m_lpBmpInfoHead = (LPBITMAPINFOHEADER)m_lpDib

//Asignar valores a las variables miembro

m_imgWidth=m_lpBmpInfoHead-gt; m_imgHeight=m_lpBmpInfoHead-gt; biHeight;

m_nBitCount=m_lpBmpInfoHead-gt; biBitCount

//Calcular la longitud de la tabla de colores

m_nColorTableLength=ComputeColorTabalLength(m_lpBmpInfoHead- gt; biBitCount);

p>

if(m_nColorTableLength==-1) return FALSE;

//Generar paleta lógica

m_hPalette = NULL ;

if( m_nColorTableLength!=0){

m_lpColorTable=(LPRGBQUAD)(m_lpDib sizeof(BITMAPINFOHEADER));

MakePalette();

}

//m_pImgData apunta a la posición inicial de los datos del mapa de bits del DIB

m_pImgData = (LPBYTE)m_lpDib sizeof(BITMAPINFOHEADER)

sizeof(RGBQUAD) * m_nColorTableLength;

}

catch(CException* pe) {

AfxMessageBox("Error de lectura"); p> pe-gt; Eliminar();

devolver FALSO;

}

//La función devuelve

devolver VERDADERO;

}

/************************************ ************ *************************

* Nombre de la función:

* Write()

*Parámetros de función:

* LPCTSTR lpszPathName: especifique el nombre y la ruta del archivo de imagen

*

*Valor de retorno:

* 0 significa fracaso, 1 significa éxito

*

*Descripción: Dada una imagen nombre del archivo y su ruta, guarde los datos DIB señalados por m_lpDib

******************************. ******************** ******************************* /

BOOL ImgCenterDib::Write(LPCTSTR lpszPath

Nombre)

{

//Abrir archivo en modo escritura

Archivo CFile;

if (!file.Open(lpszPathName, CFile ::modeCreate | CFile::modeReadWrite

| CFile::shareExclusive))

return FALSE

//Completa la estructura del encabezado del archivo

BITMAPFILEHEADER bmfh;

bmfh.bfType = 0x4d42; // 'BM'

bmfh.bfSize = 0;

bmfh.bfReserved1 = bmfh.bfReserved2 = 0;

bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) sizeof(BITMAPINFOHEADER)

sizeof(RGBQUAD) * m_nColorTableLength

prueba {

//La estructura del encabezado del archivo se escribe en el archivo

file.Write((LPVOID) amp; bmfh, sizeof(BITMAPFILEHEADER));

//La La estructura del encabezado de la información del archivo se escribe en el archivo

file.Write(m_lpBmpInfoHead, sizeof(BITMAPINFOHEADER));

//Si hay una tabla de colores, escriba la tabla de colores en el file

if(m_nColorTableLength! =0)

file.Write(m_lpColorTable, sizeof(RGBQUAD) * m_nColorTableLength);

//Los datos de mapa de bits se escriben en el archivo

int imgBufSize=( m_imgWidth*m_nBitCount/8 3)/4*4*m_imgHeight;

file.Write(m_pImgData, imgBufSize);

}

catch(CException* pe ) {

pe-gt; Delete()

AfxMessageBox("escribir error de imagen");

return FALSE

}

//Función return

return TRUE;

}

/************ ************************************* ************** *********

* Nombre de la función:

* ReemplazarDib()

*

*Parámetros de función:

* CSize size - el nuevo tamaño de imagen que se reemplazará

* int nBitCount - el número de bits por píxel

* LPRGBQUAD lpColorTable - el puntero de la tabla de colores

* carácter sin firmar *pImgData

-Puntero a datos de mapa de bits

*Valor de retorno:

* Ninguno

*

*Descripción: Dado el tamaño de la nueva imagen , bits por píxel, tabla de colores, datos de mapa de bits y otra información, reemplace el DIB existente al que apunta m_lpDib

* con el nuevo DIB

***** **** *********************************************** *** *************/

void ImgCenterDib::ReplaceDib(CSize size, int nBitCount,

LPRGBQUAD lpColorTable, unsigned char *pImgData )

{

//Liberar el espacio ocupado por el DIB original

Empty()

//Asignación de variables miembro

m_imgWidth=size.cx;

m_imgHeight=size.cy;

m_nBitCount=nBitCount

//Calcular la longitud de la tabla de colores;

m_nColorTableLength=ComputeColorTabalLength(nBitCount);

//El número de bytes ocupados por cada fila de píxeles se expande a un múltiplo de 4

int lineByte=(m_imgWidth*nBitCount/ 8 3)/4*4;

//El tamaño de los datos del mapa de bits

int imgBufSize=m_imgHeight*lineByte;

//Reasigna espacio para m_lpDib , para almacenar el nuevo DIB

m_lpDib=new BYTE [sizeof(BITMAPINFOHEADER)

sizeof(RGBQUAD) * m_nColorTableLength imgBufSize]; p> // Complete la estructura BITMAPINFOHEADER del encabezado de información del mapa de bits

m_lpBmpInfoHead = (LPBITMAPINFOHEADER) m_lpDib

m_lpBmpInfoHead-gt; biSize = sizeof(BITMAPINFOHEADER