Está en la página 1de 20

YUV Los informes de laboratorio

YVU-9 y YV-12 a RGB


Planar Formato Ejemplos
UYVY a RGB
de pic Formato Ejemplo
Escala de grises Y8
YYYYCbCr 411 a BMP Conversin

YVU-9 y YV-12 a RGB

Propsito
El propsito de este programa es demostrar cmo leer un flujo de bytes
digitales YV-12 o YVU-9 y visualizar la imagen en color RGB
correspondiente.

Materiales y equipamiento

Requisitos de software
de Windows 95/98
Delphi 3/4/5 (recompilar)
YVUtoRGBDemo.EXE con archivos de entrada YVU12.Stream y YVU9.Stream
Requisitos de hardware
VGA (o superior) de monitor en color de alta o el modo de pantalla en color
verdadero.

Procedimiento

1. Haga doble clic en el YVUtoRGBDemo.EXE icono para iniciar el


programa.
2. Seleccione la imagen YVU9 YVU12 oa travs de la caja de radio a la
izquierda.
3. Ver las imgenes Y, U, V o RGB a travs de la caja de radio de la
derecha.
4. La imagen mostrada tambin se escribe en un archivo de disco.
( WeatherLady.BMP est escrito para para la seleccin YVU-12,
mientras que NewsGuy.BMP est escrito para la seleccin YVU-9).

Discusin
de color YUV se utiliza en las transmisiones de televisin europeas. (YIQ se
utiliza en emisiones de televisin en Estados Unidos.) El componente Y de
YUV no es "amarilla", pero la luminancia. Slo el componente Y de una seal
de televisin en color se muestra en los televisores en blanco y negro. La
informacin de cromaticidad se codifica en los componentes U y V.

En lugar de almacenar una imagen como 8 bits de rojo, 8 bits de verde y 8 bits
de azul por pixel, una imagen en color RGB se puede reducir a 16 bits por
pxel por la conversin a la luminancia y el color diferencias:

Luminancia, Y = 0.299R + 0.587G + 0.114B


diferencia de color (azul), C B (tambin conocido como T) = B - Y
diferencia de color (rojo), C R (tambin conocido como V) = R - Y

Debido a que el ojo es ms sensible a los detalles de luminancia de detalles de


color, ms bits se utilizan para almacenar la informacin de luminancia de las
diferencias de color. En el estndar de compresin JPEG las diferencias de
color son sub-muestreada para reducir su contenido de datos. El JPEG 4: 1:
Esquema 1 significa que hay cuatro muestras de Y a cada muestra de C B y
C R . Vase [ Awcock96 , pp. 260-261] para ms detalles.

C B y C R es sinnimo de crominancia azul y rojo de


crominancia. Crominancia es la cantidad de brillo que es percibido por el ojo
humano. Cuanta ms luz que perciben, mayor ser el valor de crominancia

Un formato YUV comn es el formato planar, donde cada componente se


almacena como una matriz separada, con la imagen final formada por la
fusin de los tres planos separados. (Vase la UYVYInforme de Laboratorio a
continuacin para un ejemplo de formato empaquetado.) Dos formatos YUV
planas comunes son YV-12 y YVU-9.

He aqu una descripcin visual de las imgenes RGB resultantes YVU-9


formatos de archivo YV-12 y y:

YV-12
Y V T

YVU-9
Y V T
Entender el formato de una secuencia de vdeo digital es esencial en el
procesamiento de una imagen. La determinacin de las dimensiones X e Y de
una imagen en un archivo es el primer paso. En este caso, se me dio el tamao
de cada imagen.

CONST
YRowCount = 288;
YColumnCount = 352;

El prefijo "Y" en estas constantes no se refiere a la dimensin espacial "Y"


pero los datos de luminancia "Y". (Demasiados Ys aqu!)

Procesamiento Comn para YVU-9 y YV-12 imgenes es posible mediante la


introduccin de un parmetro "Factor". Esta informacin se selecciona a
travs de la RadioGroup129 de control:
Formato Factor Fichero de entrada Archivo de salida
YV-12 2 YVU12.Stream WeatherLady.BMP
YVU-9 4 YVU9.Stream NewsGuy.BMP

Los YVU12.Stream y YVU9.Stream archivos contienen toda la informacin de


la imagen. La informacin "Y" es primero, y es seguida por la "V" y la
informacin de "U":

Seccin
ndice de primer byte columnas filas
archivo
Y 0 YColumnCount YRowCount
YColumnCount * YColumnCount / YRowCount /
V
YRowCount Factor Factor
YColumnCount *
YColumnCount / YRowCount /
T YRowCount *
Factor Factor
(1 + 1 / Factor 2 )

El tamao total del archivo es YColumnCount * YRowCount * (1 + 2 /


Factor 2 ), que para los archivos de 352-por-288 es:

Tamao del archivo de 352-por-288 Imagen


Formato Factor Tamao del archivo
YV-12 2 152064
YVU-9 4 114048

La informacin Y, V y U se puede leer en el mismo archivo mediante la


apertura de tres secuencias de archivo y la bsqueda de la posicin del primer
byte de la seccin apropiada:

Streamy: = TFileStream.Create (INFILE, fmOpenRead + fmShareDenyNone);


StreamV: = TFileStream.Create (INFILE, fmOpenRead + fmShareDenyNone);
StreamU: = TFileStream.Create (INFILE, fmOpenRead + fmShareDenyNone);
...
apuntador de archivo: = 0;
StreamY.Seek (apuntador de archivo, soFromBeginning);

Apuntador de archivo: = YRowCount * YColumnCount;


StreamV.Seek (apuntador de archivo, soFromBeginning);

Apuntador de archivo: = apuntador de archivo + (YRowCount DIV Factor)


* (YColumnCount DIV Factor);
StreamU.Seek (apuntador de archivo, soFromBeginning);

Haciendo caso omiso de las paletas es siempre el enfoque ms fcil cuando se


trabaja con imgenes en color, por lo que se crea una imagen de 24 bits "color
verdadero":
Bitmap: = TBitmap.Create;
TRY
Bitmap.Width: = YColumnCount;
Bitmap.Height: = YRowCount;
Bitmap.PixelFormat: = pf24Bit;
...

A continuacin se muestra la mecnica de la lectura de las tres corrientes de la


fila de a uno por cada una de las lneas de exploracin. Tenga en cuenta las
filas U y V se utilizan Factor veces, y la informacin de los pxeles dentro de
una lnea de barrido se utiliza Factor veces.

Para j: = 0 A YRowCount-1 NO
COMENZAR
// Lea cada "fila" de datos
StreamY.Read (Buffery, YColumnCount {bytes});

// YUV12: Lee U y V "fila" de datos sobre filas de nmero par


// Re-utilizan la misma fila de datos para las filas impares
//
// YUV9: Leer nueva fila cada fila de salida cuarto. Reutilizacin
// la misma fila de las otras filas.
SI j MOD Factor = 0
luego comenzar
StreamU.Read (BufferU, YColumnCount DIV Factor {bytes});
StreamV.Read (BufferV, YColumnCount DIV Factor {bytes});
FIN;

Row: = Bitmap.Scanline [j];


FOR i: = 0 A YColumnCount-1 DO
COMENZAR
Y: = Buffery [i];
IF i MOD Factor = 0
luego comenzar
U: = BufferU [i DIV Factor];
V: = BufferV [i div Factor]
FIN;

Con la fila [i] DO


COMENZAR

<convertir de YUV a RGB para cada pxel>

FIN;
FIN
FIN;

El "convertir de YUV a RGB para cada pxel" seccin mostrada arriba es una
sentencia CASE en el programa actual para seleccionar las imgenes Y, U, V
o RGB (basado en el RadioGroupYVURGBcontrol). Las imgenes Y, U, V
son tonos de gris ya que los valores correspondientes son asignados a cada
uno de los R, G y los componentes B de pxel. Por ejemplo, la imagen Y se
crea en este caso:
CASO RadioGroupYVURGB.ItemIndex DE
// Y plano
0: BEGIN
rgbtBlue: = Y;
rgbtGreen: = Y;
rgbtRed: = Y
FIN;
...

La conversin de YUV a RGB es en este caso:

// YUV a RGB Conversin


// ver www.webartz.com/fourcc/fccyvrgb.htm
// No est claro si U y V se conmutan, o si
// la frmula de este sitio web es correcta con
// U = Cb y V = Cr
3: BEGIN
rgbtBlue: = FixRange (1,164 * (Y - 16) + 2,018 * (U-128));
rgbtGreen: = FixRange (1,164 * (Y - 16) - 0,813 * (U-128) -
0.391 * (V-128));
rgbtRed: = FixRange (1,164 * (Y - 16) + 1,596 * (V-128));
FIN;
...

El FixRange funcin impone un "piso" de 0 y un "techo" de 255:

Valores // R, G y B deben estar en el rango 0..255


FixRange FUNCIN (CONST x: Doble): BYTE;
VAR temp: Integer;
COMENZAR
temp: = ROUND (x);
Si TEMP> 255
ENTONCES temp: = 255
ELSE
IF temp <0
ENTONCES temp: = 0;

RESULTADO: = temp
FIN;

El "Tiempo Lady" y "Noticias de Guy" imgenes RGB contienen 62,193 y


45,090 colores nicos, respectivamente. (Para contar colores nicos en una
imagen, ver el Mostrar imagen Informe de Laboratorio). Considerable de
codificacin adicional es necesaria para reducir el nmero de colores nicos a
solamente 236, que es lo que se necesita para su visualizacin en Windows
256 modo de pantalla a color. Esa es la razn principal de un pf24bit se utiliz
mapa de bits en esta solucin. (Para un ejemplo de cmo utilizar
un pf8bit mapa de bits con paletas con un nmero limitado de colores, ver
el ejemplo Y8 abajo).

Por cierto, la "Y" de YUV es la gamma corregida componente "brillo" de


color; la "Y" del modelo CIE XYZ es (lineal ONU corregido) brillo. Ambos
estn relacionados, pero no son lo mismo.
Acuse de recibo
Gracias a Tarvo Hirs por proporcionarme estas imgenes y preguntar cmo
podan ser procesados.

Su equipo es un Celeron 300, 128 MB de RAM, 2x ATI ExpertXL PCI tarjeta


de video, Windows 98 con dos pantallas. Su tarjeta de captura es una ATI-TV
complemento a la tarjeta de video ATI. Se conecta a la tarjeta de vdeo a
travs de cable formato IDE, as que no hay ancho de banda se utiliza para el
transporte de imagen del televisor. Las imgenes estn en una resolucin
mxima de la tarjeta.

El canal de televisin TV3 es de Estonia. La calidad de imagen es bastante


bajo debido Tarvo no tena una antena apropiada. Se acaba de caer un cable
fuera de la ventana (lo que explica la interferencia que se pueden ver en las
imgenes de "V" de arriba - tal vez un buen punto de partida para eliminar la
interferencia con una FFT).

Conclusiones
Los seres humanos pueden discriminar la informacin monocroma espacial
mejor que la informacin de color espacial. Por lo tanto, ms bits se utilizan
para almacenar informacin Y puesto que el ojo humano es ms sensible a los
cambios en luminancia que los cambios en el matiz o saturacin, que se
comunica en los componentes U y V.

Palabras clave
YUV, RGB, YVU-9, YV-12, Scanline, TRGBTripleArray, TFileStream, la
bsqueda, SaveToFile

Archivos de
Delphi 3/4/5 Cdigo Fuente y EXE
con YUV9.Stream y YUV12.Stream archivos (319 KB): YVUtoRGB.ZIP

Tambin, ver enlaces ms abajo.

UYVY a RGB
Propsito
El propsito de este programa es para leer una secuencia de bytes UYVY y
convertir los valores YUV a RGB para la visualizacin.

Materiales y equipamiento

Requisitos de software
de Windows 95/98
Delphi 3/4/5 (recompilar)
UYVY.EXE con archivo de entrada UYVY.Stream

Requisitos de hardware
VGA (o superior) de monitor en color de alta o el modo de pantalla en color
verdadero.

Procedimiento

1. Haga doble clic en el UYVY.EXE icono para iniciar el programa.


2. Haga clic en la Leer botn para procesar la UYVY.Stream archivo y
mostrarlo en la pantalla.
3. Si lo desea, ver el UYVY.BMP archivo.

Discusin
Un grupo formato comn YUV se llama el grupo de formatos de empacado
donde las muestras Y, U y V se embalan juntos en macropixels, que se
almacenan en una sola matriz. (Vase la YVU-9 y YV-12Informe de
Laboratorio de arriba para un ejemplo de estructura plana.) Uno de estos
formatos de envasado se UYVY, que es probablemente el ms popular de los
diversos YUV 4: 2: 2 formatos.

Entender el formato de una secuencia de vdeo digital es esencial en el


procesamiento de una imagen. La determinacin de las dimensiones X e Y de
una imagen en un archivo es el primer paso. En este caso, se me dio el tamao
de cada imagen.

CONST
YUVwidth = 386;
YUVheight = 320;

(Acutally, la imagen original era 720 por 576. Este ejemplo es un subconjunto
de la original).

Cada fila de datos es una matriz de valores UYVY, donde cada valor de Y, U,
V es un solo byte. El BufferYUV matriz contiene el conjunto de registros.

TIPO
TYUVWord = // una "palabra" es siempre 2 bytes en todas las
versiones de Delphi
RECORD
UV: BYTE; // T si el ndice de la tarde; V si el ndice impar
Y: BYTE; // Y para todos los elementos de matriz
FIN;
...
VAR
BitmapRGB: TBitmap;
BufferYUV: ARRAY [0..YUVwidth-1] DE TYUVWord;

El resto del programa es relativamente straigtforward:

TIPO
...
TRGBTripleArray = ARRAY [0..YUVwidth-1] DE TRGBTriple;
pRGBTripleArray = ^ TRGBTripleArray;

VAR
BitmapRGB: TBitmap;
...
i: Integer;
j: entero;
Fila: pRGBTripleArray;
StreamYUV: TFileStream;
T: Integer;
V: INTEGER;
Y: INTEGER;

comenzar
StreamYUV: = TFileStream.Create ( 'UYVY.Stream', fmOpenRead);

TRY
BitmapRGB: = TBitmap.Create;
TRY
BitmapRGB.PixelFormat: = pf24Bit;
BitmapRGB.Width: = YUVwidth;
BitmapRGB.Height: = YUVheight;

Para j: = 0 A YUVheight-1 DO
COMENZAR
StreamYUV.Read (BufferYUV, sizeof (BufferYUV));
Row: = BitmapRGB.Scanline [j];

FOR i: = 0 A YUVwidth-1 NO
COMENZAR
IF i MOD 2 = 0 // Incluso
luego comenzar
Y: = BufferYUV [i] .Y;
U: = BufferYUV [i] .UV;
V: = BufferYUV [i + 1] .UV // obtener V de siguiente
palabra
FIN
ELSE begin // Odd
Y: = BufferYUV [i] .Y;
U: = BufferYUV [i-1] .UV; // obtener U desde ltima
palabra
V: = BufferYUV [i] .UV
FIN;

Con la fila [i] Do


EMPIEZO
// Ver "HELP conversin YUV-RGB!", 12/12/97 por
// lweng@analogic.com para esta frmula :
rgbtRed: = FixValue (1,164 * (Y-16) + 1,596 * (V-128));
rgbtGreen: = FixValue (1,164 * (Y-16) - 0,392 * (U-128) -
0.813 * (V-128));
rgbtBlue: = FixValue (1,164 * (Y-16) + 2,017 * (-128 U))
FIN
FIN

FIN;

BitmapRGB.SaveToFile ( 'UYVY.BMP');
ImageYUV.Picture.Graphic: = BitmapRGB
FINALMENTE
BitmapRGB.Free
FIN

LTIMO
StreamYUV.Free
FIN
extremo;

El FixValue funcin obliga a un piso de 0 y un mximo de 255 en los valores


R, G, B:

FixValue FUNCIN (CONST x: doble): BYTE;


VAR
i: INTEGER;
COMENZAR
i: = ROUND (x);
IF i> 255
ENTONCES Resultado: = 255
ELSE
IF i <0
ENTONCES resultado: = 0
ELSE RESULTADO: = BYTE (i)
end {FixValue};

Acuse de recibo
Gracias a Daniel Halan de Suecia por proporcionarme esta imagen y preguntar
cmo podra ser procesado.

Conclusiones
Un flujo de bytes con valores UYVY se pueden convertir fcilmente a los
pxeles RGB para la visualizacin.

Palabras clave
YUV, UYVY, RGB, TYUVWord, TFileStream, Scanline, TRGBTripleArray

Archivos de
Delphi 3/4/5 Fuente y EXE con UYVY.Stream archivo (259 KB): UYVY.ZIP

Tambin, ver enlaces ms abajo.

Escala de grises Y8

Propsito
El propsito de este programa es para leer una secuencia de bytes y mostrar la
informacin de una imagen de escala de grises como. Ambos se presentan
soluciones de paleta y no la paleta.

Materiales y equipamiento

Requisitos de software
de Windows 95/98
Delphi 3/4/5 (recompilar)
DeutschGray.EXE con archivo de entrada Gray.Stream

Requisitos de hardware
VGA (o superior) de monitor en color de alta o el modo de pantalla en color
verdadero.

Procedimiento

1. Haga doble clic en el DeutschGray.EXE icono para iniciar el programa.


2. Haga clic en el botn izquierdo del "Leer de imagen" para mostrar una
solucin que produce una pf24bit archivo BMP.
3. Haga clic en el botn "Leer Imagen" el derecho a exhibir una solucin
que utiliza paletas y produce una pf8bit archivo BMP.

Discusin
Entender el formato de una secuencia de vdeo digital es esencial en el
procesamiento de una imagen. La determinacin de las dimensiones X e Y de
una imagen en un archivo es el primer paso. En este caso, he determinado el
tamao de la imagen a partir de la informacin que me ha sido dado, y por la
inspeccin visual de un volcado hexadecimal de los bytes de imagen.

CONST
BildWidth = 392;
BildHeight = 250;

(En realidad, esta imagen es una pequea parte de la imagen original. Esto es
para reducir el tamao del archivo de descarga.)

Creacin de una imagen 256 tonos de gris utilizando un TBitmap pf24bit (para
su visualizacin en color de alta densidad o modo de color verdadero) es
bastante sencillo. Trabajar con un pf24bit mapa de bits requiere el uso de
un pRGBTripleArray para acceder a cada pxel en una lnea de escaneo de
fila :

// Leer archivo y visualizacin de mapa de bits como pf24bit - evitar


el uso de paletas
procedimiento TForm1.ButtonGray1Click (Sender: TObject);
TIPO
TRGBTripleArray = ARRAY [0..BildWidth-1] DE TRGBTriple;
pRGBTripleArray = ^ TRGBTripleArray;
VAR
mapa de bits: TBitmap;
GrayBuffer: pByteArray; // ARRAY [0..BildWidth-1] DE BYTE;
GrayStream: TFileStream;
i: INTEGER;
j: entero;
Fila: pRGBTripleArray;
comenzar
// Asignar memoria intermedia para leer archivo de imagen
GetMem (GrayBuffer, BildWidth);

TRY
Bitmap: = TBitmap.Create;
TRY
Bitmap.PixelFormat: = pf24bit; // evitar paletas
Bitmap.Width: = BildWidth;
Bitmap.Height: = BildHeight;

GrayStream: = TFileStream.Create ( 'Gray.Stream', fmOpenRead);

TRY
para j: = 0 A BildHeight-1 NO
COMENZAR
GrayStream.Read (GrayBuffer ^, BildWidth);

Row: = Bitmap.Scanline [j];


FOR i: = 0 A BildWidth-1 NO
EMPEZAR
CON Fila [i] NO
COMENZAR
rgbtBlue: = GrayBuffer [i];
rgbtGreen: = GrayBuffer [i];
rgbtRed: = GrayBuffer [i]
FIN
FIN

FIN;
// La imagen en pantalla (o guardar en el archivo aqu)
Image.Picture.Graphic: = mapa de bits;

// Guardar como archivo


Bitmap.SaveToFile ( 'Graypf24bit.BMP')

FINALMENTE
GrayStream.Free;
FIN

LTIMO
Bitmap.Free
FIN

LTIMO
FreeMem (GrayBuffer)
FIN
extremo;

La clave para mostrar un pxel tonos de gris es asignar la R, G y B


componentes del pxel del mismo valor. Cuando el rango de entrada de
valores para el byte GrayBuffer [i] es de 0 a 255, asignar el mismo valor a R,
G y B los resultados en 256 tonos de gris. Este pf24bit solucin de mapa de
bits ignora cualquier correccin de gamma.

Este pf24bit solucin no tendrn ningn problema al usar los verdaderos


modos de pantalla a color de alta color o, pero en el modo de pantalla de 256
colores, 20 de los 256 colores estn reservados por Windows para la
visualizacin de los botones, iconos, barras de desplazamiento, etc .. Esto slo
236 hojas colores para trabajar. El rango de entrada de 0 a 255 se debe asignar
a uno de los valores Pallete 236 y 236 de estas entradas de la paleta debe
abarcar los 256 posibles valores de fondo de escala de grises. (Suena casi
como doble discurso?)

Normalmente Ventana se reserva los primeros 10 y 20 ltimas entradas en la


tabla de paleta de 256 colores. Esa convencin se ha seguido hasta aqu
mediante la definicin de las entradas de la paleta 10-245.

En primer lugar, vamos a definir un LookUp mesa. Valores de byte de entrada


0 a 255 se asignan a 10 a 245 en esta bsqueda tabla:

VAR
k: INTEGER;
LookupTable: ARRAY [0..255] OF BYTE;
...
limitacin paleta de Windows para la visualizacin de 256 colores. La
gama completa
// 0..255 se puede utilizar si se utilizan slo de alta color o
pantalla a color verdadero.
// tabla de bsqueda para asignar los valores de la escala de grises
de 0 a 255 a
// 10 a 245. Esto se salta los primeros 10 y los ltimos 10 ranuras
paleta,
// que contienen los colores de las ventanas fijas.
Para k: = 0 a 255 DO
COMENZAR
LookupTable [k]: = 10 + MulDiv (k, 235, 255)
finales;

Ahora vamos a definir las 236 entradas de paleta en 10 a 245 a abarcar la


gama RGB (0,0,0) a RGB (255,255,255). [Nota: Se puede cambiar esta tabla
para reflejar una correccin de gamma , si se desea.]

// se supone colores de Windows "fijas" estn reservados para el modo


de pantalla de 256 colores.
// Es decir, reserva de la primera y la ltima 10 entradas de la
paleta de la paleta del sistema.
FUNCIN DefineShadesOfGrayPalette: HPALETTE;
CONST
PaletteVersion = $ 0300; // "nmero mgico" para LOGPALETTE de
ventana
VAR
i: Integer;
LogicalPalette: TMaxLogPalette;
ScreenDeviceContext: hDC;
COMENZAR
LogicalPalette.palVersion: = PaletteVersion;
LogicalPalette.palNumEntries: = 256;

ScreenDeviceContext: = GetDC (hWnd_DeskTop);


Pruebas a
// obtener primeras y ltimas 10 entradas de systemPalette
GetSystemPaletteEntries (ScreenDeviceContext, 0, 10,
LogicalPalette.palPalEntry [0]);
GetSystemPaletteEntries (ScreenDeviceContext, 246, 10,
LogicalPalette.palPalEntry [246])
FINALMENTE
ReleaseDC (0, ScreenDeviceContext)
FIN;

// Salto sobre la primera 10 y 10 ltimas entradas systemPalette


"fijos"
para I: A = 0 255-20 DO
COMENZAR
// entradas de la paleta stetch 0..235 para abarcar rango de
escala de grises 0..255
LogicalPalette.palPalEntry [10 + i ] .peRed: = MulDiv (i, 255,
235);
LogicalPalette.palPalEntry [10 + i] .peGreen: = MulDiv (i, 255,
235);
LogicalPalette.palPalEntry [10 + i] .peBlue: = MulDiv (i, 255,
235);
LogicalPalette.palPalEntry [10 + i] .peFlags: = PC_NOCOLLAPSE;
FIN;
RESULTADO: = CreatePalette (pLogPalette (@LogicalPalette) ^);

FIN {DefineShadesOfGrayPalette};

Trabajar con un pf8bit mapa de bits requiere el uso de un pByteArray para


acceder a cada pxel en una lnea de escaneo de fila . Con esta definicin
paleta en su lugar, el resto de la solucin paleta es muy similar a
la pf24bit solucin.

VAR
mapa de bits: TBitmap;
GrayBuffer: pByteArray; // ARRAY [0..BildWidth-1] DE BYTE;
GrayStream: TFileStream;
i: INTEGER;
j: entero;
k: INTEGER;
LookupTable: ARRAY [0..255] OF BYTE;
Fila: pByteArray;
...
// Asignar memoria intermedia para leer archivo de imagen
GetMem (GrayBuffer, BildWidth);

TRY
Bitmap: = TBitmap.Create;
TRY
Bitmap.PixelFormat: = pf8bit;
Bitmap.Width: = BildWidth;
Bitmap.Height: = BildHeight;
Bitmap.Palette: = DefineShadesOfGrayPalette;

GrayStream: = TFileStream.Create ( 'Gray.Stream', fmOpenRead);


TRY
para j: = 0 A BildHeight-1 NO
COMENZAR
GrayStream.Read (GrayBuffer ^, BildWidth);
Row: = Bitmap.Scanline [j];
FOR i: = 0 A BildWidth-1 DO
COMENZAR
Fila [i]: = LookupTable [GrayBuffer [i]]; // un byte por
pxel
FIN

FIN;

// La imagen en pantalla
Image.Picture.Graphic: = mapa de bits;

// Guardar como archivo


Bitmap.SaveToFile ( 'Graypf8bit.BMP')

FINALMENTE
GrayStream.Free
FIN

LTIMO
Bitmap.Free
FIN

LTIMO
FreeMem (GrayBuffer)
...

Este ejemplo slo involucra a 182 tonos de gris, por lo que la limitacin de
236 colores en la paleta de un nico Windows no afecta a la imagen mucho.

Para utilizar correctamente las paletas con mltiples ventanas presentes, se


necesita cdigo adicional para manejar mensajes WM_PALETTECHANGED
y WM_QUERYNEWPALETTE. Ver el Laboratorio de paleta para obtener
informacin adicional. Estos mensajes no se manejan en este programa.

Si es necesario, se extiende histograma se podra utilizar para mejorar el


contraste - ver de efg HistoStretch grises Informe de Laboratorio.

La imagen es de un alemn (Bertelsmann) Canal 7 llamado "Pro 7."

Acuse de recibo
Gracias a Sebastian Grabert de Alemania por proporcionarme esta imagen y
preguntar cmo podra ser procesado.

Conclusiones
Dado un flujo de bytes que representa la imagen tonos de gris de 0 a 255, la
pantalla es fcil con un pf24bit mapa de bits en color de alta densidad o el
modo de pantalla en color verdadero, sino que requiere codificacin adicional
considerable para la pantalla en el modo de 256 colores con una pf8bit mapa
de bits.

Palabras clave
Escala de Grises, Y8, pRGBTripleArray, pByteArray, TFileStream, Scanline,
TMaxLogPalette, GetSystemPaletteEntries, bsqueda en la tabla

Archivos de
Delphi 3/4/5 Cdigo Fuente y EXE con el archivo de datos Gray.Stream (187
KB): DeutschGray.ZIP

YYYYCrCb 411 a BMP

Propsito
El propsito de este programa es demostrar cmo mostrar el archivo 411 se
utiliza con una cmara Sony Mavica.

Materiales y equipamiento

Requisitos de software
de Windows 95/98
Delphi 3/4/5 (compilar)
el cdigo fuente C411toBMP
Archivo de muestra 411

Requisitos de hardware
del monitor VGA en color de alta densidad o el modo de pantalla a color
verdadero.

Procedimiento

1. Compilar el C411toBMP proyecto en D3 - D5. Seleccione Ejecutar.


2. Pulse el Leer 411 botn y seleccionar la muestra 411 archivo.
3. Se muestra la imagen en miniatura ..

Discusin
El flujo de bytes para una imagen de la 411 consiste en grupos de seis bytes:
Y0 Y1 Y2 Y3 Cb Cr. Cada grupo de seis bytes se convierte en
cuatro TRGBTriples en un pf24bit Scanline como sigue:

USOS
FileCtrl; // El archivo existe
// versin Delphi de programa C originalmente
// encontrado en www.hamrick.com/mavica/4112bmp.txt
FUNCIN Convert411ToBMP (CONST nombre de archivo: STRING): TBitmap;
TIPO
TYCbCr =
GRABAR
Y: ARRAY [0..3] OF BYTE;
Cb: BYTE;
Cr: BYTE
FIN;
TRGBTripleArray = ARRAY [WORD] DE TRGBTriple;
pRGBTripleArray = ^ TRGBTripleArray;
CONST
Anchura = 64; // cableado para 411 archivos
Altura = 48;
VAR
Cb, Cr: INTEGER;
Apuntador de archivo: Integer;
FileStream: TFileStream;
i, j, k: INTEGER;
R, G, B: INTEGER;
Fila: pRGBTripleArray;
YCbCr: TYCbCr;
EMPEZAR
RESULTADO: = TBitmap.Create;
RESULT.PixelFormat: = pf24bit;
RESULT.Width: = Anchura;
RESULT.Height: = Altura;
RESULT.Canvas.FillRect (RESULT.Canvas.ClipRect);
// Si el archivo no existe, se devolver un mapa de bits blanco
SI FileExists (filename)
luego comenzar
FileStream: = TFileStream.Create (nombre de archivo, fmOpenRead +
fmShareDenyNone);
TRATAR
Apuntador de archivo: = 0;
FileStream.Seek (apuntador de archivo, soFromBeginning);
// 6 bytes en 411 archivo para cada 4 pxeles: Y0 Y1 Y2 Y3 Cb Cr
Para j: = 0 A RESULT.Height-1 DO
EMPEZAR
Row: = RESULT.Scanline [j];
FOR i: = 0 TO (RESULT.WIDTH DIV 4) -1 DO
EMPEZAR
FileStream.Read (YCbCr, sizeof (TYCbCr));
Cb: = YCbCr.Cb - 128;
Cr: = YCbCr.Cr - 128;
Para k: = 0 a 3 DO
EMPEZAR
R: = YCbCr.Y [k] + redondo (1,40200 * Cr);
G: = YCbCr.Y [k] - ROUND (0,34414 * Cb + 0,71414 * Cr);
B: = YCbCr.Y [k] + ROUND (1,77200 * Cb);
Si R> 255
Entonces R: = 255
MS
Si R <0
Entonces R: = 0;
Si G> 255
Entonces G: = 255
MS
Si G <0
Entonces G: = 0;
Si B> 255
Entonces B: = 255
MS
Si B <0
Entonces B: = 0;
fila [4 * i + k] .rgbtRed: = R;
fila [4 * i + k] .rgbtGreen: = G;
fila [4 * i + k] .rgbtBlue: = B
FIN
FIN
FIN
FINALMENTE
FileStream.Free
FIN
FIN
FIN {Convert411toBMP};

Acuse de recibo
Gracias a Peter Mora en la imagen de muestra y preguntar sobre la
conversin.

Conclusiones
Ahora slo necesitan una cmara Sony Mavica!

Palabras clave
411, TBitmap, YUV, TRGBTripleArray, TFileStream

Archivos de
Delphi 3/4/5 Cdigo Fuente y archivo de ejemplo 411: 411.ZIP

Campo de golf
YCC espacio de color y compresin de imgenes
http://astronomy.swin.edu.au/~pbourke/colour/ycc

De Greg Blair UseNet mensaje con rutinas C RGBto422 y RGB420

efg de Referencia de la biblioteca de color