Imagens Imagens Computação Gráfica - Gattass.

Apresentação em tema: "Imagens Imagens Computação Gráfica - Gattass."— Transcrição da apresentação:

1 Imagens Imagens Computação Gráfica - Gattass

2 Características Básicas de Imagens
x y C C(x,y) Computação Gráfica - Gattass

3 Digitalização de Imagens
Discretização espacial (amostragem) Computação Gráfica - Gattass

4 Digitalização de Imagens
64x54 amostragem Imagem de tons (ou cores) contínuas Imagem amostrada quantização 64x cores 55 20 22 23 45 10 09 11 43 42 70 28 76 codificação Imagem amostrada e quantizada Computação Gráfica - Gattass

5 Armazenamento de Imagens
Plano de Cores Azul Verde Verm. 00 01 02 06 05 03 04 07 08 09 . . . 06 06 Pixel 0 Pixel 1 Pixel 2 Pixel 3 Pixel 4 Pixel 5 Organização dos pixels de uma imagem por planos de cores Computação Gráfica - Gattass

6 Organização de pixels num array no formato PPM (o mais simples)
Imagens Organização de pixels num array no formato PPM (o mais simples) x 1 2 ... w-1 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 1 15 16 17 18 ... 2 3 ... h-1 y Pixel (x,y) offset=3*(w*y+x); red = rgb_vector[offset]; green = rgb_vector[offset+1]; blue = rgb_vector[offset+2]; Computação Gráfica - Gattass

7 Formato PPM File_signature "P6". White_space (blanks, TABs, CRs, LFs).
Imagens Formato PPM File_signature "P6". White_space (blanks, TABs, CRs, LFs). Width, w, (ASCII decimal characters). Height, h, (ASCII decimal characters). Max_color, max, (ASCII decimal characters). Pixels, (3*w*h bytes rgb components of pixels) Comments from # to the end of line lines  70 characters Computação Gráfica - Gattass

8 Formato PPM P6 # Created by Paint Shop Pro 358 539 255
Imagens Formato PPM exemplo P6 # Created by Paint Shop Pro 255 Computação Gráfica - Gattass

9 Gravação em PPM int ppm_write(int w, int h, unsigned char *rgb,
Imagens Gravação em PPM int ppm_write(int w, int h, unsigned char *rgb, char *file_name) { FILE *fp; fp = fopen(file_name, "wb"); if (fp == NULL) return 0; if (fprintf(fp, "P6\n%d %d\n255\n", w, h) <= 0) fclose(fp); } if (fwrite(rgb, 3*w*h, 1, fp) != 1) return 1; Computação Gráfica - Gattass

10 Leitura em PPM int ppm_read(int *p_w, int *p_h, unsigned char **p_rgb,
Imagens Leitura em PPM int ppm_read(int *p_w, int *p_h, unsigned char **p_rgb, char *file_name) { FILE *fp; char line[80]; int rgb_size; int max; fp = fopen(file_name, "rb"); if (fp == NULL) { printf(”Error reading %s",file_name); return 0;} fgets(line,80,fp); if(strcmp(line,"P6\n")) { printf(”Wrong signature\n"); return 0; } while (fscanf( fp, " %d ", p_w ) != 1) fgets(line, 80, fp); while (fscanf( fp, " %d ", p_h ) != 1) while (fscanf( fp, " %d", &max ) != 1) fgetc(fp); rgb_size=3*(*p_w)*(*p_h); (*p_rgb) = (unsigned char *) calloc(rgb_size, 1); if ((*p_rgb) != NULL) fread( (*p_rgb), rgb_size, 1, fp ); fclose(fp); return 1; } Computação Gráfica - Gattass

11 Programa Simples void main(void){ int w, h; // dimensões da imagem
Imagens Programa Simples void main(void){ int w, h; // dimensões da imagem unsigned char *rgb; // bytes de rgb unsigned char r,g,b,grey; // componentes de cor int x,y; long int k; if (ppm_read(&w,&h,&rgb,"test_in.ppm")==0) return; for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { k = 3*(y*w+x); r = rgb[k]; g = rgb[k+1]; b = rgb[k+2]; grey = (unsigned char)(0.3*r+0.6*g+0.1*b); rgb[k] = grey; rgb[k+1] = grey; rgb[k+2] = grey; } ppm_write(w, h, rgb, "test_out.ppm"); free(rgb); Computação Gráfica - Gattass

12 colocado para garantir
Imagens Arquivo BMP 00 01 02 08 07 06 05 03 04 10 09 11 Pixel 0 Pixel 1 Pixel 2 Pixel 3 13 12 14 Pixel 4 15 16 17 18 ... Organização dos pixels de uma imagem RGB no arquivo BMP colocado para garantir múltiplo de 4 Computação Gráfica - Gattass

13 Microsoft Windows Bitmap - BMP
Imagens Microsoft Windows Bitmap - BMP Características Principais Mono, 4-bit, 8-bit, 24-bit Tipo de compressão: RLE / não comprimido Tamanho máximo: 64K x 64K pixels Seções (versão 3): Header Info. Header Palette Bitmap Data Computação Gráfica - Gattass

14 BMP - Header typedef struct _Win3xBitmapHeader {
Imagens BMP - Header typedef struct _Win3xBitmapHeader { WORD Type; /* Image file type 4D42h (“BM”)*/ DWORD FileSize; /* File size (bytes) */ WORD Reserved1; /* Reserved (always 0) */ WORD Reserved2; /* Reserved (always 0) */ DWORD Offset; /* Offset to bitmap data in bytes */ } WIN3XHEAD; Computação Gráfica - Gattass

15 BMP - Information Header
Imagens BMP - Information Header typedef struct _Win3xBitmapInfoHeader { DWORD Size; /* Size of this Header (40) */ DWORD Width; /* Image width (pixels) */ DWORD Height; /* Image height (pixels) */ WORD Planes; /* Number of Planes (always=1) */ WORD BitCount; /* Bits per pixel (1/4/8 or 24)*/ DWORD Compression; /* Compression (0/1/2) */ DWORD SizeImage; /* Size of bitmap (bytes) */ DWORD XPelsPerMeter; /* Horz. resol.(pixels/m) */ DWORD YPelsPerMeter; /* Vert. resol.(pixels/m) */ DWORD ClrUsed; /* Num of colors in the image */ DWORD ClrImportant; /* Num of important colors */ } WIN3XINFOHEADER; Computação Gráfica - Gattass

16 BMP - Palette typedef struct _Win3xPalette {
Imagens BMP - Palette typedef struct _Win3xPalette { RGBQUAD Palette[ ]; /* 2, 16, or 256 elem. */ } WIN3XPALETTE; typedef struct _Win3xRgbQuad BYTE Blue; /* 8-bit blue component */ BYTE Green; /* 8-bit green component */ BYTE Red; /* 8-bit red component */ BYTE Reserved; /* Reserved (= 0) */ } RGBQUAD; Computação Gráfica - Gattass

17 Imagens BMP - Image Data Notas Cada scan line em um arquivo BMP é sempre um múltiplo de 4. Imagens com1-, 4-, e 8-bits usam uma palheta de cores. Imagens com 24-bits guardam a cor diretamente, na ordem azul, verde e vermelho. O armazenamento da imagem é sempre feito a partir do canto esquerdo inferior. Computação Gráfica - Gattass

18 Transformações Geométricas
Imagens Transformações Geométricas Escala como uma re-amostragem de uma função interpolação 14 x 10 10 x 8 filtragem 8 x 5 Computação Gráfica - Gattass

19 Escala por replicação ou amostragem de pontos
Imagens Escala por replicação ou amostragem de pontos 14 x 10 10 x 8 8 x 5 for (xsrc, ysrc Î Source) { cor = Source (xsrc, ysrc) xdst = (wdst-1)*xsrc/(wsrc- 1) ydst = (hdst-1)*ysrc/(hsrc- 1) Pixel (xdst, ydst, cor) } for (xdst, ydst Î Destination) { xsrc = (wsrc-1)*xdst/(wdst - 1) ysrc = (hsrc-1)*ydst/(hdst- 1) cor = Source (xsrc, ysrc) Pixel (xdst, ydst, cor) } L K Computação Gráfica - Gattass

20 Escala Rápida: código xsrc xsrc xdst xdst codex: [ 0, 1, 1, 2, 2, 3]
Imagens Escala Rápida: código xsrc xsrc xdst xdst codex: [ 0, 1, 1, 2, 2, 3] [ 0, 2, 3, 5] float xsrc; for (xdst=0; xdst<wdst; xdst++) { xsrc = (wsrc - 1)*xdst/(wdst - 1); codex [xdst ] = ROUND(xsrc); } float xsrc = 0; float Dxsrc = (wsrc - 1)/(wdst - 1); for (xdst=0; xdst<=wdst; xdst++) { xsrc += Dxsrc; codex [xdst ] = ROUND(xsrc); } ou Computação Gráfica - Gattass

21 Escala Rápida: algoritmo
Imagens Escala Rápida: algoritmo int xsrc, ysrc, xdst, ydst; int *codex, *codey; for (xdst=0; xdst<wdst; xdst++) for (ydst=0; ydst<hdst; ydst++) { xsrc = codex[xdst]; ysrc = codey[ydst]; cor = Source[xsrc] [ysrc]; Pixel (xdst, ydst, cor); } Computação Gráfica - Gattass

22 Transformações Geométricas Rápidas: Amostragem de Pontos
Imagens Transformações Geométricas Rápidas: Amostragem de Pontos xscr yscr ydst T(xscr,yscr) T-1(xdst,ydst) xdst for (xsrc, ysrc Î Source) { cor = Source (xsrc, ysrc) xdst = Tx (xsrc, yscr) ydst = Ty (xscr,ysrc)) Pixel (xdst, ydst, cor) } for (xdst, ydst Î Destination) { xsrc = Tx-1(xdst, ydst) ysrc = Ty-1(xdst ,ydst) cor = Source (xsrc, ysrc) Pixel (xdst, ydst, cor) } L L quais são os pixels do destino? Computação Gráfica - Gattass

23 Determinação dos pixels do destino
Imagens Determinação dos pixels do destino ydst xdst ý ou xscr yscr þ Computação Gráfica - Gattass

24 Cálculo incremental da transformação geométrica
Imagens Cálculo incremental da transformação geométrica Suponha que: xsrc = Tx-1(xdst, ydst) = a xdst+ b ydst + c ysrc = Ty-1(xdst ,ydst) = d xdst+ e ydst + f xsrc = Tx-1(xdst+1, ydst) = a (xdst+1)+ b ydst + c ysrc = Ty-1(xdst+1,ydst) = d (xdst+1)+ e ydst + f Dx xsrc = a Dx ysrc = d Dy xsrc = b Dy ysrc = e Computação Gráfica - Gattass

25 Exigências sobre transformações de imagens
Translação por zero tem que ser a identidade; Sequência de translações devem produzir o mesmo efeito que uma composta da origem ao destino; Escalar por um fator l, maior que 1, e depois escalar por 1/l deve produzir a identidade; Rotação por uma sequência de ângulos que totalizem 3600 deve produzir a identidade. Computação Gráfica - Gattass

26 Composição de imagens com cor transparente
for (xdst, ydst Î Destination) { xsrc = Tx-1(xdst, ydst) ysrc = Ty-1(xdst ,ydst) cor = Source (xsrc, ysrc) if (cor != transparente) Pixel (xdst, ydst, cor) } Computação Gráfica - Gattass

27 Composição de imagens com máscaras
1 AND Computação Gráfica - Gattass

28 Imagens Animação de sprites Computação Gráfica - Gattass

29 Colocação de transparência no código da cor
Imagens Colocação de transparência no código da cor source 1 source 2 R1 G1 B1 A1 R2 G2 B2 A2 f( A1,A2 ) destination Rd Gd Bd Ad por exemplo: Rd = (A1R1+A2R2)/(A1+A2) Gd = (A1G1+A2G2)/(A1+A2) Bd = (A1B1+A2B2)/(A1+A2) Computação Gráfica - Gattass

30 Compressão de imagens Compressão de Imagens Sem Perda Com Perda
Preserva de forma controlada o nível de qualidade da imagem Taxas de compressão que chegam a valores de mais de 100 : 1 Preserva exatamente o conteúdo da imagem Taxas de compressão 3 : 1 Computação Gráfica - Gattass

31 Métodos de compressão Sem perdas Run length encoding (RLE) - repetição
Imagens Métodos de compressão Sem perdas Run length encoding (RLE) - repetição Huffman coding - histograma Predictive coding - diferenças Block coding (LZW) - dicionário Com perdas Truncation coding - reduz a representação Predictive coding - descarta diferenças altas Block coding - dicionário aproximado Transform coding - descarta frequencias altas Métodos compostos: JPEG, MPEG Computação Gráfica - Gattass

32 Processo de compressão e descompressão
Imagens Processo de compressão e descompressão Dados da Imagem Original Dados da Imagem Original 32, 45, 57, 68, 23, 100, 98, ... 32, 45, 57, 68, 23, 100, 98, ... Compressão da imagem Descompressão da imagem 32, 45, 57, 68, 23, 100, 98, ... 32, 45, 57, 68, 23, 100, 98, ... Transporte e/ou Armazenamento Imagem Comprimida Imagem Comprimida Computação Gráfica - Gattass

33 Fundamentos da Compressão de Imagens
A compressão de uma imagem é obtida quando se elimina a redundância de: codificação entre pixels psico-visual Computação Gráfica - Gattass

34 Redundância entre pixels
Imagens Redundância entre pixels 640 colunas x 480 linhas x 1 byte/pixel = 300 KBytes 480*(1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0) = ~18 Kbytes onde 1 = 32 bytes de preto e 0 = 32 bytes de branco Computação Gráfica - Gattass

35 Compressão - RLE Objetivo Reduzir a quantidade de dados redundantes.
Imagens Compressão - RLE Objetivo Reduzir a quantidade de dados redundantes. Exemplo AAAAAAxxx 6A3x Caracterísiticas Simples e rápido, porém a eficiência depende da imagem a ser comprimida. Computação Gráfica - Gattass

36 Run-Length Encoding 76 78 79 80 76 | 5 78 | 1 79 | 4 80 | 2
Imagens Run-Length Encoding 76 78 79 80 76 | 5 78 | 1 79 | 4 80 | 2 imagem binária . . . 1 1 1 1 1 7 4 5 Computação Gráfica - Gattass

37 Codificação de Huffman
Imagens Codificação de Huffman s p a2 0.4 0.6 a6 0.3 a1 0.1 0.2 a4 a3 0.06 a5 0.04 s p a2 0.4 1 0.6 a6 0.3 00 a1 0.1 011 0.2 010 01 a4 0100 a3 0.06 01010 0101 a5 0.04 01011 Computação Gráfica - Gattass

38 Redundância de Codificação
Imagens Redundância de Codificação r p(r) Code 1 l(r) l(r)p(r) Code 2 l(r) l(r)p(r) 0.19 000 3 0.57 11 2 0.38 1/7 0.25 001 3 0.75 01 2 0.50 2/7 0.21 010 3 0.63 10 2 0.42 3/7 0.16 011 3 0.48 001 3 0.48 4/7 0.08 100 3 0.24 0001 4 0.32 5/7 0.06 101 3 0.18 00001 5 0.30 6/7 0.03 110 3 0.09 000001 6 0.18 1 0.02 111 3 0.06 000000 6 0.12 1.00 Lavg= 3.00 Lavg= 2.70 rk = tons de cinza em uma imagem, k=0, 1, ..., -1 p(rk) = nk / n onde nk = número de pixels com tom rk n = número de pixels da imagem 11 10 01 001 0001 00001 000001 000000 Computação Gráfica - Gattass

39 Resultado da Teoria da Informação
Imagens Resultado da Teoria da Informação r p(r) Code 1 l(r) l(r)p(r) Code 2 log(1/p) log(1/p)*p 0.19 000 3 0.57 11 2 0.38 2.4 0.46 1/7 0.25 001 0.75 01 0.50 2.0 2/7 0.21 010 0.63 10 0.42 2.3 0.47 3/7 0.16 011 0.48 2.6 4/7 0.08 100 0.24 0001 4 0.32 3.6 0.29 5/7 0.06 101 0.18 00001 5 0.30 4.1 6/7 0.03 110 0.09 000001 6 5.1 0.15 1 0.02 111 000000 0.12 5.6 0.11 =1.00 Lavg = 3.00 2.70 Lopt = 2.65 Computação Gráfica - Gattass

40 Armazenamento Vetorial (AutoCAD DXF, Microsoft SYLK, ...) Luz e Cor
Imagens 03/22/96 Armazenamento Vetorial (AutoCAD DXF, Microsoft SYLK, ...) Computação Gráfica - Gattass Computação Gráfica - Gattass 1

41 Armazenamento Bitmap (BMP,GIF, PCX, TIFF, ...) pixel Imagens
Computação Gráfica - Gattass

42 Armazenamento Metafile (vetorial + bitmap)
Imagens Armazenamento Metafile (vetorial + bitmap) (CGM, Microsoft Windows Metafile) Animação (FLI, GRASP, ...) Multimedia (Microsoft RIFF, Apple QuickTime) Computação Gráfica - Gattass