apostila java2d (correta)

APOSTILA JAVA 2D

DISCIPLINA DE COMPUTAÇÃO

GRÁFICA

Prof.ª M.ª Eng.ª Elaine Cecília Gatto

Bauru-SP

2015

of 22

Sumário JAVA 2D ......................................................................................................................................................................... 3

1. Hierarquia de Classes ............................................................................................................................................ 3

2. Sistema de Coordenadas ...................................................................................................................................... 3

3. Contextos Gráficos ................................................................................................................................................ 3

4. Cores ..................................................................................................................................................................... 3

4.1 Constantes de Cor ........................................................................................................................................... 4

4.2 Construtores e métodos Color ....................................................................................................................... 4

4.3 Métodos Graphics para manipular Colors ...................................................................................................... 4

5. Fontes ................................................................................................................................................................... 4

5.1 Construtores, Constantes e métodos de Font ................................................................................................ 4

5.2 Métodos Graphics para manipular Fontes ..................................................................................................... 5

5.3 Métodos FontMetrics ..................................................................................................................................... 5

5.3 Métodos Graphics para obter a FontMetrics de uma Font ............................................................................ 5

6. Linhas, retângulos e ovais ..................................................................................................................................... 5

6.1 Métodos Graphics para desenhar linhas, retângulos e ovais ......................................................................... 5

7. Arcos ..................................................................................................................................................................... 7

7.1 Métodos Graphics para desenhar arcos ......................................................................................................... 7

8. Polígonos e polilinhas ........................................................................................................................................... 8

8.1 Métodos Graphics para desenhar polígonos .................................................................................................. 8

8.2 Construtores e Métodos da classe Polygon ................................................................................................... 8

9. API Java2D............................................................................................................................................................. 9

9.1 Visão Geral ...................................................................................................................................................... 9

9.2 Coordenadas ................................................................................................................................................. 10

9.3 Renderização ................................................................................................................................................ 11

9.4 Primitivas Geométricas ................................................................................................................................. 14

9.5 Textos............................................................................................................................................................ 15

9.6 Fontes ........................................................................................................................................................... 15

9.7 Layout de Texto ............................................................................................................................................ 15

9.8 Rendering Hints para texto ........................................................................................................................... 15

9.9 Imagens ......................................................................................................................................................... 16

9.10 Impressão ................................................................................................................................................... 16

9.10 Métodos ...................................................................................................................................................... 16

10. Exercícios .......................................................................................................................................................... 21

of 22

JAVA 2D

1. Hierarquia de Classes

Classe Color: contém métodos e constantes para manipular cores

Método paintComponent: desenha imagens gráficas em um componente

Classe Font: contém métodos e constantes para manipular fontes

Classe FontMetrics: contém métodos para obter informações de fontes

Classe Graphics: contém métodos para desenhar Strings, Linhas, Retângulos e outras formas geométricas básicas

Classe Graphics2D: estende a classe Graphics, desenha com a API do Java2D

Classe Polygon: contém métodos para criar polígonos

Classe BasicStroke: especifica as características de desenho de linhas

Classes GradientPaint e TexturePaint: especificam as características para preencher formas com cores ou padrões

Classes General Path, Line2D, Arc2D, Ellipse2D, Rectangule2D e RoudRectangle2D: representam as formas

geométricas

2. Sistema de Coordenadas

É um esquema para identificar cada ponto na tela

O canto superior esquerdo de um componente de interface gráfica em Java tem as coordenadas (0,0)

Coordenada x: coordenada horizontal – é distância horizontal que vai do lado direito ao lado esquerdo da tela

Coordenada y: coordenada vertical – é a distância vertical de baixo para cima da tela

Um par de coordenadas é composto pelas coordenadas x e y

Eixo x: descreve cada coordenada horizontal

Eixo y: descreve cada coordenada vertical

Coordenadas são utilizadas para indicar onde as imagens gráficas devem ser exibidas na tela

Pixels: unidade de medida. É a menos unidade de exibição de resolução de um monitor.

3. Contextos Gráficos

Um contexto gráfico em Java permite desenhar na tela

Objeto Graphics:

o Gerencia o contexto gráfico

o Desenha pixels na tela

o Contém métodos para desenhar e manipular fontes, cores, etc.

Como Java é independente de plataforma, as imagens gráficas serão apresentadas na tela conforme o sistema o qual

está executando (Windows, Linux, etc.)

Classe Component: superclasse

Classe JComponent: herda de Component, contém o método paintComponent, é uma superclasse de JPanel

Método paintComponent: o public void paintComponent(Graphics g)

o Recebe um objeto Graphics como argumento.

o O objeto Graphics é passado para o método paintComponent pelo sistema quando um componente de

interface gráfica precisa ser repintado

o g é um parâmetro que recebe uma referencia a uma instancia da subclasse específica de sistema

Método repaint: o é chamado pelo programador para solicitar uma chamada ao método paintComponent. o public void repaint()

4. Cores

RGB = red, green, blue

Valores inteiros: 0 a 255

Valores de ponto flutuante: 0.0 a 1.0

16,7 milhões de cores disponíveis no Java

Objetos Color são imutáveis (isto é, não modificáveis)

of 22

Para alterar as cores, você sempre deve criar um novo objeto Color

Como alternativa, pode usar uma das constantes Color

4.1 Constantes de Cor

Color Cor Valor RGB public final static Color RED Vermelho 255,0,0 public final static Color GREEN Verde 0,255,0 public final static Color BLUE Azul 0,0,255 public final static Color ORANGE Laranja 255,200,0 public final static Color PINK Cor-de-rosa 255,175,175 public final static Color CYAN Ciano 0,255,255 public final static Color MAGENTA Magenta 255,0,255 public final static Color YELLOW Amarelo 255,255,0 public final static Color BLACK Preto 0,0,0 public final static Color WHITE Branco 255,255,255 public final static Color GRAY Cinza 128,128,128 public final static Color LIGHT_GRAY Cinza Claro 192,192,192 public final static Color DARK_GRAY Cinza Escuro 64,64,64

4.2 Construtores e métodos Color

Método Descrição

public Color( int r, int g, int b) Cria uma cor com base nos componentes vermelho, verde, azul,

expressos com valores inteiros entre 0 e 255

public Color( float r, float g, float b) Cria uma cor com base nos componentes vermelho, verde, azul

expressos com valores de ponto flutuante entre 0.0 e 1.0

public int getRed() Retorna um valor entre 0 e 255 representando o conteúdo

vermelho public int getGreen() Retorna um valor entre 0 e 255 representando o conteúdo verde public int getBlue() Retorna um valor entre 0 e 255 representando o conteúdo azul

4.3 Métodos Graphics para manipular Colors

Método Descrição public Color getColor() Retorna o objeto Color que representa as cores atuais no contexto gráfico Public void setColor(Color c) Configura a cor atual para desenho com contexto gráfico

5. Fontes

O número de fontes varia de um sistema operacional para outro.

O Java fornece cinco nomes lógicos de fontes:

o Serif;

o Monospaced;

o SansSerif;

o Dialog;

o DialogInput.

O JRE em cada plataforma mapeia esses nomes lógicos de fonte para fontes reais instaladas na plataforma

5.1 Construtores, Constantes e métodos de Font

Método Descrição public final static int PLAIN Uma constante representando um estilo de fonte simples public final static int BOLD Uma constante representando um estilo de fonte negrito public final static int ITALIC Uma constante representando um estilo de fonte itálico

public Font(String name, int style,

int size)

Cria um objeto Font com o nome, o estilo e o tamanho de fonte

especificada.

of 22

public int getStlye() Retorna um valor inteiro indicando o estilo de fonte atual public int getSize() Retorna um valor inteiro indicando o tamanho da fonte atual public String getName() Retorna o nome da fonte atual como uma string public String getFamily() Retorna o nome da família de fontes como uma string public boolean isPlain() Retorna true se a fonte for simples, caso contrário false public boolean isBold() Retorna true se a fonte for negrito, caso contrário false public boolean isItalic() Retorna true se a fonte for itálica, caso contrário false

5.2 Métodos Graphics para manipular Fontes

Método Descrição public Font getFont() Retorna uma referência de objeto Font representando a fonte atual

Public void setFont(Font f) Configura a fonte atual como a fonte, o estilo e o tamanho especificados pela

referência de objeto Font f

5.3 Métodos FontMetrics

Método Descrição public int getAscent() Retorna a ascendente de uma fonte em pontos public int getDescent() Retorna a descendente de uma fonte em pontos public int getLeading() Retorna a entrelinha de uma fonte em pontos Public int getHeight() Retorna a altura de uma fonte em pontos

5.3 Métodos Graphics para obter a FontMetrics de uma Font

Método Descrição public FontMetrics getFontMetrics() Retorna o objeto FontMetrics para o desenho atual Font

Public FontMetrics getFontMetrics (Font f) Retorna o objeto FontMetrics para o argumento Font

especificado

6. Linhas, retângulos e ovais

Cada método de desenho requer um parâmetro de largura e altura

Largura e altura devem ser valores não negativos

6.1 Métodos Graphics para desenhar linhas, retângulos e ovais

Método Descrição public void drawLine(int x1, int y1, int

x2, int y2) Desenha uma linha entre o ponto (x1,y1) e o ponto (x2,y2)

public void drawRect(int x, int y, int

largura, int altura)

Desenha um retângulo com a largura e a altura

especificadas.

O canto superior esquerdo do retângulo tem as coordenadas

(x,y).

Somente o contorno do retângulo é desenhado utilizando a

cor do objeto de Graphics.

O corpo do retângulo não é preenchido com essa cor.

public void fillRect(int x, int y, int


Desenha um retângulo sólido com a largura e a altura

especificadas.


(x,y)

O retângulo é preenchido com a cor do objeto Graphics

public void clearRect(int x, int y, int


Desenha um retângulo preenchido com a largura e a altura

especificadas na cor de fundo atual.

of 22


(x,y).

Esse método é útil se o programador quiser remover uma

parte de uma imagem

public void drawRoundRect(int x, int y,

int largura, int altura, int archWidth,

int arcHeight)

Desenha um retângulo com cantos arredondados na cor atual

com a largura e a altura especificadas.

arcWidth e arcHeight determinam o arredondamento dos

cantos

Somente o contorno da forma é desenhado

public void fillRoundRect(int x, int y,

int largura, int altura, int arcWidth, int

arcHeight)

Desenha um retângulo com cantos arredondados na cor atual

com a largura e a altura especificadas.

arcWidth e arcHeight determinam o arredondamento dos

cantos

public void draw3DRect(int x, int y, int

largura, int altura, boolean b)

Desenha um retângulo tridimensional na cor atual com a

largura e a altura especificadas.


(x,y)

O retângulo parece em alto relevo quando b é verdadeiro e

em baixo relevo quando b é falso


public void fill3DRect(int x, int y, int

largura, int altura, boolean b)

Desenha um retângulo tridimensional na cor atual com a

largura e a altura especificadas.


(x,y)

O retângulo parece em alto relevo quando b é verdadeiro e

em baixo relevo quando b é falso

public void drawOval(int x, int y, int


Desenha uma oval na cor atual com a largura e a altura

especificadas

O canto superior esquerdo do retângulo delimitador está nas

coordenadas (x,y)

A oval toca todos os quatro lados do retângulo associado no

centro de cada lado


public void fillOval(int x, int y, int


Desenha uma oval na cor atual com a largura e a altura

especificadas

O canto superior esquerdo do retângulo delimitador está nas

coordenadas (x,y)

A oval toca todos os quatro lados do retângulo associado no

centro de cada lado

Figura 1: Oval unida por um retângulo

of 22

Figura 2: Largura e altura do arco para retângulos arredondados

7. Arcos

Um arco é desenhado como uma parte de uma oval

Uma oval é delimitada por um retângulo

Os arcos varrem a partir de um ângulo inicial até o número de graus especificados pelos seus ângulos de arco

Arcos movem-se ao longo de uma curva

Os ângulos de arco são medidos em graus

Arcos varrem, a partir de um ângulo inicial, o número de graus especificado por seu ângulo de arco

Ao desenhar um arco, especificamos um retângulo delimitador para uma oval

O arco varrerá parte da oval

7.1 Métodos Graphics para desenhar arcos

Método Descrição

public void drawArc(int x, int y, int

largura, int altura, int anguloInicial,

int anguloDoArco)

Desenha um arco em relação ao canto superior esquerdo do

retângulo delimitador e coordenadas x e y com a largura e a

altura especificadas.

O segmento de arco começa a ser desenhado no

anguloInicial e a curva, no anguloDoArco

public void fillArc(int x, int y, int

largura, int altura, int anguloInicial,

int anguloDoArco)

Desenha um arco preenchido – um setor – em relação as

coordenadas x e y do canto superior esquerdo do retângulo

delimitador com a largura e a altura especificadas.

O segmento de arco começa a ser desenhado no

anguloInicial e a curva, no anguloDoArco

Figura 3: Ângulos de arco positivo

of 22

Figura 4: Ângulos de arco negativo

8. Polígonos e polilinhas

Polígonos são formas de múltiplos lados compostas de segmentos de linhas retas

Polilinhas são sequencias de pontos conectados

8.1 Métodos Graphics para desenhar polígonos

Método Descrição

public void drawPoligon(int xPoints[], int

yPoints[], int points)

Desenha um polígono

A coordenada x de cada ponto é especificada no array

xPoints, e a coordenada y de cada ponto, no array yPoints

O último argumento especifica o número de points

Esse método desenha um polígono

Se o último ponto for diferente do primeiro, o polígono é

fechado por uma linha que conecta o último ponto ao

primeiro

public void drawPolyline(int xPoints[],

int yPoints[], int points)

Desenha uma sequencia de linhas conectadas


xPoints, e a coordenada y de cada ponto é especificada no

arrayPoints


Se o último ponto for diferente do primeiro, a polilinha não

é fechada public void drawPolygon(Polygon p) Desenha o polígono especificado

public void fillPolygon(int xPoints[], int

yPoints[], int points)

Desenha um polígono preenchido


xPoints, e a coordenada y de cada ponto é especificada no

arrayPoints


Esse método desenha um polígono

Se o último ponto for diferente do primeiro, o polígono é

fechado por uma linha que conecta o último ponto a primeiro

public void fillPolygon(Polygon g) Desenha o polígono preenchido especificado.

O polígono é fechado

8.2 Construtores e Métodos da classe Polygon

Método Descrição

public Polygon() Constrói um novo objeto polígono

O polígono não contem nenhum ponto

public Polygon(int xValues[], int

yValues[], int numberOfPoints)

Constrói um novo objeto de polígono

O polígono tem numberOfPoints lados, com cada ponto

consistindo em uma coordenada x de xValues e uma

of 22

coordenada y de yValues public void addPoint(int x, int y) Adiciona pares das coordenadas x e y ao Polygon

9. API Java2D

Recursos para processamento de:

o line art (traço)

o texto

o imagens

Pacotes:

o Java.awt.image

o Java.awt.color

o Java.awt.font

o Java.awt.geom

o Java.awt.print

o Java.awt.image.renderable

Graphics2D

o Subclasse abstrata da classe Graphics

o Contém capacidades gráficas

o Para acessar as capacidades de Graphics2D, devemos fazer a coerção da referência Graphics (g) passada a

paintComponent para uma referência Graphics2D com a instrução Graphics2D g2d = (Graphics2D) g;

9.1 Visão Geral

A API Java 2D fornece gráficos bidimensionais, texto e recursos de imagens para programas Java através de

extensões para o Abstract Windowig Toolkit (AWT). Este pacote de renderização abrangente suporta linha art, texto e imagens

em uma estrutura flexível, cheia de recursos para o desenvolvimento de interfaces ricas de usuário, programas de desenho

sofisticados e editores de imagem. Objetos Java 2D existem em um plano chamado de coordenadas do espaço, ou apenas o

espaço do usuário. Quando os objetos são processados em uma tela ou uma impressora, as coordenadas de espaço do usuário

são transformadas em coordenadas espaciais do dispositivo. A API Java 2D fornece seguintes capacidades:

o Um modelo de rendereização uniforme de dispositivos de exibição e impressoras;

o Uma ampla gama de primitivas geométricas, tais como retângulos, curvas, e elipses, bem como um

mecanismo para renderizar virtualmente qualquer forma geométrica;

o Mecanismos de desempenho e detecção em formas, texto e imagens;

o Um modelo de composição que fornece controle sobre como os objetos de sobreposição são processados;

o Suporte de cor aprimorada, que facilita o gerenciamento de cores;

o Suporte para a impressão de documentos complexos;

o Controle da qualidade da renderização através da utilização de render.

of 22

A classe Graphics2D estende a classe Graphics para fornecer um controle mais sofisticado sobre a geometria,

transformações de coordenadas, gerenciamento de cores e layout de texto. Esta classe é fundamental para renderizar e

dimensionar formas, textos e imagens na plataforma Java.

9.2 Coordenadas

A API Java 2D mantém dois espaços de coordenadas: espaço do usuário e espaço do dispositivo.

Espaço do usuário: O espaço em que os gráficos primitivos são especificados. Espaço do usuário é um sistema

lógico de coordenadas independente do dispositivo, o espaço de coordenadas que seu programa usa. Todas as formas

geométricas passadas para rotinas de renderização 2D do Java são especificados em coordenadas de espaço do usuário.

Espaço do dispositivo: O sistema de um dispositivo de saída de coordenadas, tais como uma tela, uma janela ou uma

impressora. Espaço do dispositivo é um sistema de coordenadas dependentes do dispositivo que varia de acordo com o

dispositivo de processamento alvo. Embora o sistema de coordenadas para uma janela ou tela pode ser muito diferente do

sistema de coordenadas de uma impressora, estas diferenças são invisíveis para programas Java. As conversões necessárias

entre o espaço do usuário e espaço de dispositivo são executadas automaticamente durante o processamento.

Quando a transformação padrão a partir do espaço do usuário para o espaço do dispositivo é utilizada, a origem do

espaço do usuário é o canto superior esquerdo da área de desenho do componente. A coordenada x aumenta para a direita, e a

coordenada y aumenta para baixo. O canto superior esquerdo de uma janela é 0,0. Todas as coordenadas são especificadas

usando números inteiros, o que é geralmente suficiente. No entanto, alguns casos exigem ponto flutuante de precisão dupla, ou

mesmo que também são suportados.

Todas as coordenadas passadas para um objeto Graphics2D são especificadas em um sistema independente de

dispositivo de coordenadas chamado espaço do usuário, que é usado por aplicativos. O objeto contém um objeto Graphics2D

AffineTransform como parte de seu estado de renderização que define como converter coordenadas de espaço do usuário para

coordenadas dependentes do dispositivo no espaço de dispositivos.

Coordenadas em espaço de dispositivo geralmente se referem a dispositivos individuais pixels e estão alinhados sobre

as lacunas infinitamente finas entre esses pixels. Alguns objetos Graphics2D podem ser usados para capturar as operações de

renderização para armazenamento em um metarquivo gráfico para reprodução em um dispositivo desconhecido concreto de

resolução física em um momento posterior. Uma vez que a resolução não pode ser conhecida quando as operações de

renderização são capturadas, o Graphics2D Transform está configurado para transformar as coordenadas do usuário para um

espaço de dispositivo virtual que aproxima a resolução esperada do dispositivo de destino. Outras transformações podem

precisar ser aplicadas no período de reprodução, se a estimativa é incorreta.

Algumas das operações realizadas pela renderização de atributos e objetos ocorrem no espaço de dispositivo, mas

todos os métodos Graphics2D usam coordenadas espaciais do usuário. Todo objeto Graphics2D está associado a um alvo que

define onde a renderização ocorre. Um objeto GraphicsConfiguration define as características do alvo de renderização, como

formato e resolução de pixel. O mesmo alvo de processamento é utilizado durante toda a vida de um objeto Graphics2D.

Ao criar um objeto Graphics2D, o GraphicsConfiguration especifica a transformação padrão para o destino do

Graphics2D (um componente ou imagem). Esta transformação padrão mapeia o sistema de coordenadas de espaço do usuário

para as coordenadas de tela e dispositivo de impressora. A escala da transformação padrão está definida para a identidade para

aqueles dispositivos que estão perto de 72 dpi, tais como dispositivos de tela. A escala da transformação padrão está definida

para aproximadamente 72 o espaço de coordenadas do usuário por polegada quadrada para dispositivos de alta resolução,

como impressoras. Para buffers de imagem, transformação padrão é a transformação identidade.

of 22

9.3 Renderização

A API Java 2D fornece um modelo de renderização uniforme entre os diferentes tipos de dispositivos. No nível do

aplicativo, o processo de renderização é o mesmo se o alvo dispositivo de renderização é uma tela ou uma impressora. Quando

um componente precisa ser exibido, a sua pintura ou método de atualização é automaticamente invocado com o contexto

gráfico apropriado.

A API Java 2D inclui a classe java.awt.Graphics2D, que estende a classe Graphics para fornecer acesso aos gráficos

melhorados e renderização recursos da API do Java 2D. Esses recursos incluem:

Renderização do esboço de qualquer primitiva geométrica, utilizando os atributos de pintura (método paint).

Renderização de qualquer primitiva geométrica, preenchendo seu interior com a cor ou o padrão especificado pelos

atributos de paint (método draw).

Renderização de qualquer seqüência de texto (método drawString). O atributo de fonte é usado para converter a

seqüência de glifos, que são preenchidos com a cor ou o padrão especificado pelos atributos de paint.

Renderização da imagem especificada (o método drawImage).

Além disso, a classe Graphics2D suporta os métodos de renderização de gráficos para formatos específicos, como

drawOval e fillRect. Todos os métodos que são representados acima podem ser divididos em dois grupos: Métodos para

desenhar uma forma e Métodos que afetam a renderização. O segundo grupo dos métodos utiliza os atributos de estado que

formam o contexto Graphics2D para:

Variar a largura do traçado

Alterar a forma como formas são unidas

Definir um caminho de recorte para limitar a área

Traduzir, girar, escalar, cisalhar objetos quando eles são renderizados

Definir cores e padrões para preencher formas

Especificar como compor vários objetos gráficos

Para empregar recursos da API Java 2D na sua aplicação, uma coersão do objeto Graphics que é passado para método

de renderização de um componente a um objeto Graphics2D deve ser realizada. Por exemplo:

public void paint (Graphics g) {

Graphics2D g2 = (Graphics2D) g;

... }

O contexto de renderização classe Graphics2D contém vários atributos. O atributo pen é aplicado ao contorno de uma

forma. Este atributo permite que você desenhe linhas com qualquer tamanho de ponto e padrão de linha. O atributo fill é

aplicado ao interior da forma. Este atributo permite que você preencha formas com cores sólidas, gradientes e padrões. O

atributo de compositing é usado quando os objetos se sobrepõem a objetos existentes. O atributo de transform é aplicado

durante o processamento para converter o objeto processado a partir do espaço do usuário para as coordenadas do dispositivo e

do espaço. Transformações opcionais como translação, rotação, dimensionamento ou corte também podem ser aplicados por

este atributo. O clip restringe a renderização para a área dentro do contorno do objeto usado para definir o caminho de recorte.

Qualquer objeto da forma pode ser usado para definir o clip. O atributo font é usado para converter sequências de texto para

glifos. Hit rendering especifica preferências entre velocidade e qualidade. Por exemplo, você pode especificar se a suavização

deve ser utilizada, se esse recurso estiver disponível. Quando um atributo é definido, o objeto de atributo apropriado é passado.

of 22

Como mostra o exemplo, para alterar o atributo de paint para um azul-esverdeado de preenchimento gradiente, você deve

construir um objeto GradientPaint e, em seguida, chamar o método setPaint.

gp = new GradientPaint(0f,0f,blue,0f,30f,green);

g2.setPaint(gp);

9.3.1 Processo de Renderização

O processo de renderização pode ser dividido em quatro fases, que são controladas pelos atributos de renderização

Graphics2D. O processador pode otimizar muitos desses passos, seja por cache os resultados para futuras chamadas, como por

passos virtuais múltiplos em uma operação simples, como por reconhecer vários atributos como casos comuns ou simples que

podem ser elimiados pela modificação de parte das operações. As etapas do processo de renderização são:

1. Determine o que renderizar;

2. Restringir a operação de renderização para o clip atual. O clip é especificado por uma forma no espaço do usuário e

é controlado pelo programa usando os vários métodos de manipulação de clip de gráficos e Graphics2D. Este clip do

usuário é transformado em espaço dispositivo pela Transformada atual e combinado com o clip do dispositivo, a qual

é definida pela visibilidade de janelas e as extensões do dispositivo. A combinação do clip do usuário e o do

dispostivo define o clip compósito, que determina a última região de recorte. O clip do usuário não é modificado pelo

sistema de renderização para refletir o clip compósito resultante.

3. Determinar quais cores serão renderizadas;

4. Aplicar as cores para a superfície de desenho destino usando o atributo Composite atual no contexto Graphics2D.

Os três tipos de operações de renderização, juntamente com os detalhes de cada um dos seus processos de

transformação específicos são:

1. Operações de forma

Se a operação for um draw (Forma) operação, então o método createStrokedShape no atributo do traçado

corrente no contexto Graphics2D é utilizado para construir um novo objeto de forma que contém o contorno

da forma especificada.

O Shape é transformado a partir do espaço do usuário para o espaço do dispositivo usando a Transformada

atual no contexto Graphics2D.

O contorno da forma é extraído utilizando o método getPathIterator de Shape, que retorna um objeto

PathIterator que itera ao longo do limite do Shape.

Se o objeto Graphics2D não consegue lidar com os segmentos de curva que o objeto PathIterator retorna em

seguida, ele pode chamar o método alternativo getPathIterator de Shape, que achata a Shape.

A pintura atual no contexto Graphics2D é consultado para um contexto de Paint, que especifica as cores para

renderizar no espaço dispositivo.

2. Operações de Texto

Os passos seguintes são usados para determinar o conjunto de glifos necessários para tornar a seqüência

indicada:

of 22

o Se o argumento for uma cadeia de caracteres, então a fonte corrento no contexto Graphics2D é

solicitada a converter os caracteres Unicode no String em um conjunto de glifos para a apresentação

com qualquer layout básico e moldar os algoritmos de fonte implementados;

o Se o argumento é um AttributedCharacterIterator, o iterador é solicitado a converter-se a um

TextLayout usando seus atributos de fonte incorporados. O TextLayout implementa algoritmos mais

sofisticados de layout de glifo que realizam ajustes de layout Unicode bi-direcional

automaticamente para várias fontes de diferentes direções de escrita;

o Se o argumento é um GlyphVector, então o objeto GlyphVector já contém os códigos de glifos

específicos de fonte apropriados com coordenadas explícitas para a posição de cada glifo.

A fonte atual é consultada para obtenção de contornos para os glifos indicados. Estes contornos são tratados

como formas no espaço do usuário em relação à posição de cada glifo que foi determinada no passo 1.

Os contornos de caracteres são preenchidos como acima indicado no âmbito de ações de forma.

A pintura atual é consultada para um PaintContext, que especifica as cores para renderizar no espaço

dispositivo.

3. Operações de imagem

A região de interesse é definida pela caixa delimitadora da Fonte da imagem. Esta caixa delimitadora é

especificada na imagem do espaço, que é o sistema de coordenadas local do objeto de imagem.

Se um AffineTransform é passado para drawImage (Imagem, AffineTransform, ImageObserver), o

AffineTransform é utilizado para transformar a caixa delimitadora do espaço de imagem do espaço do

usuário. Se nenhum AffineTransform é fornecido, a caixa delimitadora é tratada como se ela já estivesse no

espaço do usuário.

A caixa delimitadora da Fonte da imagem é transformada a partir do espaço do usuário para o espaço do

dispositivo usando Transformada. Note-se que o resultado da transformação da caixa delimitadora não

resulta necessariamente numa região retangular no espaço dispositivo.

O objeto de imagem determina as cores que serão renderizadas, recolhidas de acordo com a origem para o

destino mapeado de coordenadas especificado pelo atual Transform e a imagem transformação de imagem.

9.3.2 Problemas de Compatibilidade de Renderização

O modelo de renderização do JDK (TM) 1.1 baseia-se num modelo pixelization que especifica que as coordenadas

são infinitamente finas, que se encontram entre os pixels. Operações de estiramento são realizadas usando uma caneta de

largura de um pixel que enche o pixel abaixo e para a direita do ponto de ancoragem no caminho. O modelo é consistente com

as capacidades da maioria das classes existentes de representantes de plataformas que precisam resolver coordenadas inteiras a

uma caneta discreta que deve ser completamente em um número especificado de pixels.

O Java 2D (tm) (Java (TM) 2 plataforma) API suporta renderizadores de anti-serrilhamento. Uma caneta com uma

largura de um pixel não precisa ser completamente em N pixels em oposição ao pixel de N + 1. A caneta pode ser parcialmente

em ambos os pixels. Não é necessário escolher uma direção de polarização para uma caneta de largura, desde que a mistura

que ocorre ao longo das bordas da caneta de passagem faça com que a posição de sub-pixels da caneta seja visível para o

usuário. Por outro lado, quando antialiasing está desligado, definindo a chave KEY_ANTIALIASING para o valor

VALUE_ANTIALIAS_OFF, o processador pode precisar aplicar um viés para determinar quais pixels modificar quando a

caneta está montando uma fronteira de pixels, como quando é desenhada ao longo de um número inteiro de coordenadas no

espaço de dispositivo.

of 22

API Java 2D mantém a compatibilidade com JDK 1.1 no seu comportamento de processamento, de tal forma que as

operações de legado e comportamento renderizador não é alterado sob API Java 2D. Graphics2D estende gráficos com base

nas configurações do Curso e transformam atributos e hints de renderização. A definição executa de forma idêntica sob

configurações de atributo padrão. Por exemplo, o curso padrão é um BasicStroke com uma largura de 1 e não arrojado e o

padrão Transform para o desenho da tela é a transformação identidade.

9.4 Primitivas Geométricas

A API Java 2D fornece um conjunto útil de formatos padrão, como pontos, linhas, retângulos, arcos, elipses e curvas.

O pacote mais importante para definir primitivas geométricas comuns é o pacote java.awt.geom. Formatos arbitrários podem

ser representados pelas combinações de primitivas geométricas. A interface SHAPE representa uma forma geométrica, que tem

um contorno e um interior. Essa interface fornece um conjunto comum de métodos para descrever e inspecionar objetos

geométricos bidimensionais e apoia segmentos de linha curvos e várias sub-formas. A classe Graphics suporta apenas

segmentos de linha reta. A interface SHAPE pode suportar segmentos de curvas.

9.4.1 Pontos

A classe Point2D define um ponto que representa um local em (x, y) de coordenadas de espaço. O termo "ponto" na

API Java 2D não é o mesmo que um pixel. Um ponto não tem nenhuma área, não contém uma cor, e não pode ser processado.

Os pontos são usados para criar outras formas. A classe Point2D também inclui um método para calcular a distância entre dois

pontos.

9.4.2 Linhas

A classe Line2D é uma classe abstrata que representa uma linha. Coordenadas de uma linha podem ser recuperadas

como um double. A classe Line2D inclui vários métodos para definir pontos de extremidade de uma linha. Você também pode

criar um segmento de linha reta usando a classe GeneralPath.

9.4.3 Formas Retangulares

As primitivas Rectangle2D, RoundRectangle2D, Arc2D, e Ellipse2D são todos derivados da classe RectangularShape.

Esta classe define métodos para objetos Shape que podem ser descritos por uma caixa delimitadora retangular. A geometria de

um objeto RectangularShape podem ser extrapolados a partir de um rectângulo que envolve completamente o contorno da

forma.

9.4.4 Curvas

O QuadCurve2D permite que você crie segmentos de curva quadrática paramétrica. Uma curva quadrática é definida

por dois pontos finais e um ponto de controle. A classe CubicCurve2D permite que você crie segmentos de curva paramétrica

cúbicas. Uma curva cúbica é definida por dois pontos de extremidade e dois pontos de controle.

9.4.5 Formas Arbitrárias

A classe GeneralPath permite construir uma forma arbitrária, especificando uma série de posições ao longo do limite

da forma. Estas posições podem ser ligadas por segmentos de linha, curvas quadráticas, ou (curvas Bezier) cúbicas. Um

of 22

caminho geral é uma forma construída a partir de linhas retas e curvas complexas. Um caminho geral é representado com um

objeto da classe GeneraPath.

9.4.6 Áreas

Com a classe Area, você pode executar operações booleanas, como a união, intersecção, subtração e, em quaisquer

dois objetos Shape. Esta técnica, muitas vezes referida como área de geometria construtiva, permite que você crie rapidamente

objetos Shape complexos sem ter de descrever cada segmento de linha ou curva.

9.5 Textos

A API Java 2D tem vários recursos de renderização de texto, incluindo os métodos de renderização de strings para

definir os atributos de fonte e layout de texto. Se você quiser apenas desenhar uma cadeia de texto estático, o caminho mais

direto é usar a classe Graphics por meio do método drawString. Para especificar a fonte, você usa o método setFont da classe

Graphics. Se você quiser implementar suas próprias rotinas de edição de texto ou se precisar de mais controle sobre o layout do

texto do que os componentes de texto fornecem, você pode usar as classes de layout de texto Java 2D no pacote java.awt.font.

9.6 Fontes

As formas que uma fonte usa para representar os caracteres em uma seqüência de caracteres são chamados glifos. Um

caracter em particular ou combinação de caracteres pode ser representada como um ou mais glifos. Por exemplo, a pode ser

representado por dois glifos, enquanto que a palavra fi pode ser representada por um único glifo. Uma fonte pode ser pensada

como uma coleção de grifos. Uma única fonte pode ter muitas faces, como itálico e regular. Todas as faces de uma fonte tem

características tipográficas semelhantes e podem ser reconhecidos como membros da mesma família. Em outras palavras, uma

coleção de glifos com um estilo particular formar uma face de fonte. Uma coleção de faces de fonte forma uma família de

fontes. A coleção de famílias de fontes forma o conjunto de fontes que estão disponíveis no sistema. Quando você estiver

usando a API do Java 2D, você deve especificar fontes usando uma instância de Font. Você pode determinar quais fontes estão

disponíveis chamando o método GraphicsEnvironment.getLocalGraphicsEnvironment e depois consultar o

GraphicsEnvironment retornado. O método getAllFonts retorna uma matriz que contém instâncias de fonte para todas as fontes

disponíveis no sistema. O método getAvailableFontFamilyNames retorna uma lista das famílias de fontes disponíveis.

9.7 Layout de Texto

São dois os mecanismos do Java 2D para o gerenciamento de layout de texto: 1. A classe TextLayout gerencia a

disposição do texto. As facilidades proporcionadas pelo TextLayout está em lidar com os casos mais comuns, incluindo strings

com fontes mistas, lingaugens mistass e texto bidirecional; 2. Você pode criar objetos GlyphVector usando a classe Font e, em

seguida, tornando cada objeto GlyphVector através da classe Graphics2D. Assim, você pode completamente controlar como o

texto é moldado e posicionado.

9.8 Rendering Hints para texto

of 22

A API Java 2D permite que você controle a qualidade de formas e renderização de texto usando rendering hints.

Rendering Hints são encapsulados pela classe java.awt.RenderingHints. Tal como aplicado a texto, esta capacidade é usada

para suavização (que também é conhecido como arestas lisas). Por exemplo, o hint KEY_TEXT_ANTIALIASING permite-lhe

controlar a suavização de texto separadamente da suavização de outras formas.

9.9 Imagens

Na API Java 2D uma imagem é tipicamente uma matriz bidimensional retangular de pixels, em que cada pixel

representa a cor nessa posição da imagem e em que as dimensões representam a extensão horizontal (largura) e a extensão

vertical (altura) da imagem como ele é exibido. A classe de imagem mais importante para a representação de tais imagens é a

classe java.awt.image.BufferedImage. A API Java 2D armazena o conteúdo de tais imagens na memória para que eles possam

ser acessados diretamente. Os aplicativos podem criar diretamente um objeto BufferedImage ou obter uma imagem de um

formato de imagem externo, como PNG ou GIF. Em ambos os casos, o aplicativo pode, então, desenhar sobre a imagem

usando chamadas de API do Java 2D Graphics. Assim, as imagens não estão limitadas a exibição de imagens fotográficas.

Diferentes objetos como line art, texto e outros gráficos e até mesmo outras imagens podem ser desenhados para uma imagem.

A API Java 2D permite que você aplique operações de filtragem de imagem para BufferedImage e inclui diversos filtros

embutidos. Por exemplo, o filtro ConvolveOp pode ser usado para a nitidez de imagens. A imagem resultante pode então ser

enviada para uma tela, para uma impressora ou salva em um formato gráfico, como PNG, GIF etc.

9.10 Impressão

Todo componente Swing e Gráficos Java 2D, incluindo gráficos e imagens compostas, podem ser processados para

uma impressora usando a API do Java Printing 2D. Esta API também fornece características de composição que lhe permitem

realizar operações como alterar a ordem em que as páginas são impressas. Renderização em uma impressora é como

renderização para uma tela. O sistema de impressão controla quando as páginas são renderizadas, assim como os controles do

sistema de desenho quando um componente é pintado na tela. A API Java Printing 2D é baseado em um modelo de retorno de

chamada em que o sistema de impressão, não o aplicativo, controla quando as páginas são impressas. O aplicativo fornece o

sistema de impressão com informações sobre o documento a ser impresso, e o sistema de impressão determina quando cada

página precisa ser trabalhada. As duas características seguintes são importantes para suportar a impressão: 1. Controle do

trabalho: iniciar e gerenciar o trabalho de impressão, incluindo a exibição das caixas de diálogo de impressão e configuração

padrão; 2. Paginação: Renderização de cada página quando o sistema de impressão solicitar. Quando as páginas precisam ser

trabalhadas, o sistema de impressão chama o método de impressão do aplicativo com um contexto de gráficos adequado. Para

usar os recursos da API Java 2D quando você imprime, você lança o objeto Graphics a uma classe Graphics2D, assim como

você faz quando você vai renderizar na tela.

9.10 Métodos

Método Descrição

public abstract void

addRenderingHints(Map<?,?> hints)

Define os valores de um número arbitrário de preferências para os

algoritmos de processamento. Apenas os valores para os hints de

processamento que estão presentes no objeto Map especificado

of 22

são modificados. Todas as outras preferências não presentes no

objeto especificado são deixadas sem modificações. Hints

Rendering incluem controles para renderização qualidade e tempo

/ qualidade geral no processo de renderização. Consulte a classe

RenderingHints para definições de algumas chaves e valores

comuns.

public abstract void clip(Shape s)

Intercepta o clip atual com o interior da forma especificada e

define o clip para o cruzamento resultante. A forma especificada é

transformada com o Graphics2D atual antes de ser cruzado com o

clip atual. Este método é usado para fazer o clip corrente menor.

Para fazer o clip maior, use SetClip. O clipe modificado por este

método é independente do recorte associado com os limites do

dispositivo e visibilidade. Se nenhum clip foi previamente

definido, ou se o clip tenha sido apagado usando SetClip com um

argumento nulo, o formato especificado se torna o novo clip do

usuário.

public abstract void draw(Shape s)

Strokes o contorno de uma forma usando as configurações do

contexto Graphics2D atual. Os atributos de renderização aplicadas

incluem o Clip, transformações, paint, composição e atributos de

traçado.

public void draw3DRect(int x,

int y, int width, int height,

boolean raised)

Desenha um retângulo 3D especificado. As bordas do retângulo

são destacadas para que apareçam a ser recortada e iluminada a

partir do canto superior esquerdo. As cores utilizadas para o efeito

de realce são determinadas com base na cor atual. O retângulo

resultante abrange uma área que é largura + 1 pixels de largura por

altura + 1 pixels de altura. Este método usa a cor corrente de

COLOR exclusivamente ignorando a cor corrente de Paint


drawGlyphVector(GlyphVector g, float

x, float y)

Processa o texto da GlyphVector especificado usando atributos de

renderização do contexto Graphics2D. Os atributos de

renderização aplicadas incluem o Clip, Transform, Paint, e

atributos compostos. O GlyphVector especifica glifos individuais

a partir de uma fonte. O GlyphVector também pode conter as

posições glifo. Este é o caminho mais rápido para processar um

conjunto de caracteres para a tela.


drawImage(BufferedImage img,

BufferedImageOp op,

int x, int y)

Processa um BufferedImage que é filtrada com um

BufferedImageOp. Os atributos de renderização aplicadas incluem

o Clip, Transform e atributos compostos. Isto é equivalente a:

img1 = op.filter(img, null);

drawImage(img1, new

AffineTransform(1f,0f,0f,1f,x,y), null);

public abstract boolean

drawImage(Image img, AffineTransform

xform ImageObserver obs)

Transmite uma imagem, aplicando uma transformação do espaço

de imagem para o espaço do usuário antes de desenhar. A

transformação do espaço do utilizador para o espaço do

dispositivo é feito com a atual Transformada no Graphics2D. A

transformação especificada é aplicada à imagem antes do atributo

transformação no contexto Graphics2D ser aplicado.. Os atributos

de renderização aplicadas incluem o clip, Transform e atributos

compostos. Note-se que nenhuma renderização será feita se a

transformação especificada é noninvertible.


drawRenderableImage(RenderableImage

img, AffineTransform xform)

Processa um RenderableImage, aplicando uma transformação do

espaço de imagem para o espaço do usuário antes de desenhar. A

transformação do espaço do usuário para o espaço do dispositivo é

feito com a atual Transformada no Graphics2D. A transformação

especificada é aplicada à imagem antes do atributo transformação

of 22

no contexto Graphics2D ser aplicado. Os atributos de renderização

aplicadas incluem o clip, Transform e atributos compostos. Note-

se que nenhuma renderização será feita se a transformação

especificada é noninvertible. Hints Rendering definidas no objeto

Graphics2D podem ser usadas na geração da RenderableImage. Se

o controle explícito é necessário sobre hints rendering

reconhecidas por uma RenderableImage específico, ou se o

conhecimento de quais hints são utilizados é necessário, em

seguida, um RenderedImage devem ser obtidos diretamente do

RenderableImage e renderizar usando drawRenderedImage.


drawRenderedImage(RenderedImage img,

AffineTransform xform)

Processa um RenderedImage, aplicando uma transformação do

espaço de imagem para o espaço do usuário antes de desenhar. A

transformação do espaço do usuário para o espaço do dispositivo é

feito com a atual Transformada no Graphics2D. A transformação

especificada é aplicada à imagem antes do atributo transformação

no contexto Graphics2D ser aplicado. Os atributos de renderização

aplicadas incluem o clipe, Transformar e atributos compostos.

Note-se que nenhuma renderização será feita se a transformação

especificada é noninvertible.


drawString(AttributedCharacterIterator

iterator,float x,float y)

Processa o texto do iterador especificado aplicando seus atributos,

de acordo com a especificação da classe TextAttribute. A linha de

base do primeiro caractere está na posição (x, y) no espaço do

usuário. Para caracteres em sistemas de escrita, como hebraico e

árabe, os glifos podem ser renderizados a partir da direita para a

esquerda, caso em que a coordenada fornecida é o local do

caractere mais à esquerda na linha de base.


drawString(AttributedCharacterIterator

iterator,int x, int y)

Processa o texto do iterador especificado aplicando seus atributos,

de acordo com a especificação da classe TextAttribute. A linha de


usuário. Para caracteres em sistemas de escrita, como hebraico e

árabe, os glifos podem ser renderizados a partir da direita para a

esquerda, caso em que a coordenada fornecida é o local do

caractere mais à esquerda na linha de base.

public abstract void drawString(String

str, float x, float y)

Processa o texto especificado pela String especificada, usando o

estado do atributo text atual no contexto Graphics2D. A linha de


usuário. Os atributos de renderização aplicados incluem o Clip,

Transform, Paint, Font e atributos compostos. Para caracteres em

sistemas de escrita, como hebraico e árabe, os glifos podem ser

renderizados a partir da direita para a esquerda, caso em que a

coordenada fornecida é o local do caractere mais à esquerda na

linha de base.

public abstract void drawString(String

str,int x,int y)

Processa o texto especificado pela String especificada, usando o

estado do atributo text atual no contexto Graphics2D. A linha de


usuário. Os atributos de renderização aplicadas incluem o Clip,

Transform, Paint, Font e atributos compostos. Para caracteres em

sistemas de escrita, como hebraico e árabe, os glifos podem ser

renderizados a partir da direita para a esquerda, caso em que a

coordenada fornecida é o local do caractere mais à esquerda na

linha de base.

public abstract void fill(Shape s)

Preenche o interior de um Shape usando as configurações do

contexto Graphics2D. Os atributos de renderização aplicadas

incluem o Clip, Transform, Paint, e Composite.

public void fill3DRect(int x, int y,

int width, int height,boolean raised)

Pinta um retângulo 3D preenchido com a cor atual. As bordas do

of 22

retângulo são destacadas para que ele apareça como se as bordas

fossem chanfradas e iluminadas a partir do canto superior

esquerdo. As cores utilizadas para o efeito de realce e para o

enchimento são determinadas a partir de cores atuais. Este método

usa a cor atual de COLOR exclusiva e ignora o PAINT atual.

public abstract Color getBackground()

Retorna a cor de fundo usada para limpar uma região.

public abstract Composite

getComposite()

Retorna o atual Composite no contexto Graphics2D.

public abstract GraphicsConfiguration

getDeviceConfiguration()

Retorna a configuração do dispositivo associado a este

Graphics2D.

public abstract FontRenderContext

getFontRenderContext()

Obter o contexto de renderização da fonte dentro deste contexto

Graphics2D. O FontRenderContext encapsula hints tais como

anti-aliasing e métricas fracionárias, bem como informações

específicas do dispositivo de destino, tais como pontos por

polegada. Esta informação deve ser fornecida pelo aplicativo ao

utilizar objetos que realizam a formatação tipográfica, como Fonte

e TextLayout. Esta informação também deve ser fornecida por

aplicações que executam seu próprio layout e necessite de

medidas precisas e várias características de glifos, como

sobrescrito e altura da linha quando vários hints rendering forem

aplicados para a renderização de texto.

public abstract Paint getPaint()

Retorna a pintura atual do contexto Graphics2D.

public abstract Object

getRenderingHint(RenderingHints.Key

hintKey)

Retorna o valor de uma única preferência para os algoritmos de

processamento. Hints Rendering incluem controles para

renderização qualidade e tempo / qualidade trade-off geral no

processo de renderização.

public abstract RenderingHints

getRenderingHints()

Obtém as preferências para os algoritmos de processamento.

Categorias dica incluem controles para renderização qualidade e

tempo / qualidade trade-off geral no processo de renderização.

Retorna todos os pares chave hint / valor que já foram

especificados em uma operação.

public abstract Stroke getStroke()

Retorna o curso atual no contexto Graphics2D.

public abstract AffineTransform

getTransform()

Retorna uma cópia do atual Transform no contexto Graphics2D.

public abstract boolean hit(Rectangle

rect, Shape s, boolean onStroke)

Verifica se ou não a forma especificada intercepta o retângulo

especificado, que está em espaço de dispositivo. Se onStroke é

false, esse método verifica se ou não o interior da forma

especificada intercepta o retângulo especificado. Se onStroke é

verdade, este método verifica se ou não o traçado do contorno da

forma especificada intercepta o retângulo especificado. Os

atributos de renderização tidos em conta incluem o Clip,

Transform, e os atributos de traçado.

public abstract void rotate(double

theta)

Concatena o atual Graphics2D Transform com uma rotação

transformar. Renderização subsequente é executado pelo radianos

especificados em relação à origem anterior. Isso é equivalente a

chamar transform (R), onde R é um AffineTransform representado

pela seguinte matriz:

[ cos(theta) -sin(theta) 0 ]

[ sin(theta) cos(theta) 0 ]

[ 0 0 1 ]

Rotativo com um teta ângulo positivo gira pontos no eixo x

of 22

positivo para o eixo y positivo.

public abstract void rotate(double

theta, double x, double y)

Concatena o atual Graphics2D Transform com uma transformação

de rotação translação. Renderização subsequente é transformada

por uma transformação que é construída por traduzir para o local

especificado, executando pelos radianos especificados, e traduzir

de volta pelo mesmo montante que a tradução original. Isto é

equivalente à seguinte sequência de chamadas:

translate(x, y);

rotate(theta);

translate(-x, -y);

Rotativo com um teta ângulo positivo gira pontos no eixo x

positivo para o eixo y positivo.

public abstract void scale(double sx,

double sy)

Concatena o atual Graphics2D Transform com uma transformação

de escala. A renderização subsequente é redimensionada de

acordo com os fatores de escala especificados relativos ao

dimensionamento anterior. Isso é equivalente a chamar transform

(S), onde S é um AffineTransform representado pela seguinte

matriz:

[ sx 0 0 ]

[ 0 sy 0 ]

[ 0 0 1 ]


setBackground(Color color)

Define a cor de fundo para o contexto Graphics2D. A cor de fundo

é usada para limpar a região. Quando um Graphics2D é construído

para um componente, a cor de fundo é herdada do componente.

Definir a cor de fundo no contexto Graphics2D afeta apenas as

chamadas subseqüentes clearRect e não a cor de fundo para o

componente. Para alterar o plano de fundo do componente, use

métodos adequados do componente.


setComposite(Composite comp)

Define o Composite para o contexto Graphics2D. O composto é

usado em todos os métodos de desenho como drawImage,

drawString, paint e fill. Ele especifica como novos pixels devem

ser combinados com os pixels existentes no dispositivo gráficos

durante o processo de renderização. Se neste contexto Graphics2D

está chegando ao Componente na tela de exibição e o Composite é

um objeto personalizado, em vez de uma instância da classe

AlphaComposite, e se houver um gerente de segurança, o seu

método checkPermission é chamado com um AWTPermission

("readDisplayPixels") permissão.

public abstract void setPaint(Paint

paint)

Define o atributo de pintura para o contexto Graphics2D. Chamar

esse método com um objeto pintura nulo não tem qualquer efeito

sobre o atributo de pintura atual deste Graphics2D.


setRenderingHint(RenderingHints.Key

hintKey, Object hintValue)

Define o valor de uma única preferência para os algoritmos de

processamento. Rendering Hint incluem controles para




setRenderingHints(Map<?,?> hints)

Substitui os valores de todas as preferências para os algoritmos de

processamento com os hints especificadas. Os valores existentes

para todas as referências de renderização são descartados e um

novo conjunto de sugestões e valores conhecidos são inicializados

a partir do objeto Map especificado. Incluem controles para



public abstract void setStroke(Stroke

s)

Define o curso para o contexto Graphics2D.

of 22


setTransform(AffineTransform Tx)

Substitui o Transform no contexto Graphics2D. AVISO: Este

método nunca deve ser usado para aplicar uma nova coordenada

transformada em cima de uma transformação existente porque o

Graphics2D já pode ter uma transformação que é necessária para

outros fins, tais como renderização de componentes Swing ou

aplicar uma transformação de escala para ajustar a resolução de

uma impressora. Para adicionar uma transformação, use os

métodos transform, rotate, scale ou shear. O método setTransform

é destinado apenas para restaurar o Graphics2D original conforme

o exemplo:

// Get the current transform

AffineTransform saveAT = g2.getTransform();

// Perform transformation

g2d.transform(...);

// Render

g2d.draw(...);

// Restore original transform

g2d.setTransform(saveAT);

public abstract void shear(double shx,

double shy)

Concatena o atual Graphics2D Transform com um corte de

transformação. Representações subsequentes são cortados pelo

multiplicador relativo especificado para a posição anterior. Isso é

equivalente a chamar de transformação (SH), onde SH é uma

AffineTransform representado pela seguinte matriz:

[ 1 shx 0 ]

[ shy 1 0 ]

[ 0 0 1 ]


transform(AffineTransform Tx)

Compõe um objeto AffineTransform com a Transformada neste

Graphics2D de acordo com a regra “last-specified-first-applied”.

Se a Transform atual é Cx, o resultado da composição com Tx é

um novo Transform Cx '. Cx 'se torna a Transformada atual para

este Graphics2D. Transformar um ponto p pela Transformada

atualizada Cx 'é equivalente ao primeiro transformador p por Tx e,

em seguida, transformar o resultado do original Transform Cx. Em

outras palavras, Cx '(p) = Cx (Tx (p)). Uma cópia do Tx é feita, se

necessário, para mais alterações Tx não afeta a renderização.

public abstract void translate(double

tx, double ty)

Concatena o atual Graphics2D Transform com uma translação. A

Renderização subsequente é traduzida pela distância especificada

em relação à posição anterior. Isso é equivalente a chamar de

transformação (T), onde T é uma AffineTransform representado

pela seguinte matriz:

[ 1 0 tx ]

[ 0 1 ty ]

[ 0 0 1 ]

public abstract void translate(int x,

int y)

Traduz a origem do contexto Graphics2D para o ponto (x, y) no

atual sistema de coordenadas. Modifica o contexto Graphics2D

para que sua nova origem corresponda ao ponto (x, y) no sistema

de coordenadas do contexto Graphics2D. Todas as coordenadas

utilizadas em operações de renderização subseqüentes neste

contexto gráfico são relativas a esta nova origem.

10. Exercícios

of 22

Para todos os exercícios listados abaixo, desenvolver um aplicativo Java, usando os recursos da API Java2D.

10.1 Desenhe uma série de oito círculos concêntricos. Os círculos devem estar separados por 10 pixels usando o método

drawArc.

10.2 Desenhe uma série de oito círculos concêntricos. Os círculos devem estar separados por 10 pixels usando o método

Ellipse2D

10.3 Desenhe linhas aleatórias com cores e espessuras aleatórias usando Line2D.

10.4 Desenhe três triângulos gerados aleatoriamente em cores diferentes. Cada triangulo deve ser preenchido com uma cor

diferente. Use GeneralPath.

10.5 Desenhe aleatoriamente caracteres em diferentes tamanhos de fontes e cores.

10.6 Desenhe uma grade de 8 X 8 usando o método drawLine.

10.7 Desenhe uma grade de 10 X 10 usando o método drawRect.

10.8 desenhe uma grade 10 X 10 usando o método Rectangle2D.

10.9 Desenhe um tetraedro (pirâmide) usando GeneralPath.

10.10 Desenhe um cubo usando GeneralPath.

10.11 Desenvolva um aplicativo que solicita ao usuário inserir o raio de um círculo como um número de ponto flutuante e

desenha o círculo, bem como os valores do diâmetro do círculo, circunferência e área. Também deve ser solicitado ao usuário

um conjunto de coordenadas além do raio. Desenhe o circulo e exiba o diâmetro, a circunferência e a área do círculo utilizando

um objeto Ellipse2D para representar o círculo e o método draw da classe Graphics2D para exibi-lo. Use o valor 3.14159 para

o PI.

apostila java2d (correta)

Education