LORD-SPACE: Desenho 2D em Java - A Classe Basic Stroke e outras
Desenho 2D em Java - A Classe Basic Stroke e outras
A CLASSE BASICSTROKE.
A classe de BasicStroke define um jogo básico de atributos para os esboços dos gráficos primitivos, os mesmos tem um rendimento com ao de um objeto de Graphics2D, onde tem seu atributo do curso ajustado ao BasicStroke.
Os atributos definidos por BasicStroke descrevem a forma da marca feita por uma pena extraída ao longo do esboço de uma forma e das decorações aplicadas nas extremidades e juntam-na de segmentos do trajeto da forma, incluindo a largura, onde a largura da pena, é perpendicular a sua medida.
Classes Principais do BasicStroke são:
A classe Image define uma imagem gráfica simples, genérica e bidimensional. A classe Graphics (usada pelo método paint) pode desenhar imagens com o método drawImage :
minhaImagem = createImage(50, 50);
g.drawImage(minhaImagem, 0, 0, this);
O método drawImage recebe quatro parâmetros - a imagem, as coordenadas x e y e a referência para ela mesma através da variável especial (this). Os formatos de gravura suportados pelos browsers, os mais comuns são os que possuem extensão GIF (Graphics Interchange Format) e o Joint Photographic Experts Group (JPEG). Essas imagens podem demorar um tempo para serem descarregadas.
public class draw_image extends Applet {
img = getImage(getCodeBase(), "cow.gif");
g.drawImage(img, 0, 0, this); } }
// Adiciona imagens
Formas, fontes e cores
Os recursos gráficos como formas, fontes e cores são utilizados a partir da classe java.awt, que proporciona o melhor acabamento visual da linguagem Java.
A maioria das operações básicas de desenho é composta de métodos definidos na classe Graphics. Não é necessário criar um objeto "Graphics" para desenhar algo, basta lembrar que um dos argumentos do método paint() é um objeto Graphics, como é demonstrado logo abaixo no exemplo que vai nos acompanhar por todo esse capítulo, demonstrando todo o processo de criação de um mapa da Flórida:
public class Map extends java.applet.Applet {
. . . . . . .} }
Esse applet usa o método drawString() do objeto screen para desenhar o string "Flórida" nas coordenadas 185,75. Assim como acontece com drawString(), todos os métodos de desenho possuem argumentos que indicam coordenadas x, y. Alguns exigem mais do que um conjunto de coordenadas, como uma linha que possui uma coordenada x, y para identificar seu ponto inicial e outra para seu ponto final. Lembrando que todos os valores em pixel são inteiros, não podendo ser usados números decimais para apresentar algo entre os valores inteiros.
O método drawLine() é usado para desenhar uma linha entre dois pontos. O método recebe quatro argumentos: as coordenadas x e y do ponto inicial e as coordenadas x e y do ponto final. A espessura da linha fica fixa em 1 pixel. Será inserida a seguinte linha no código do Map:
screen.drawLine(185, 80, 222, 80);
Para desenhar um retângulo normal, use o método drawRect para os contornos e o método fillRect para as figuras preenchidas. Esses métodos recebem os seguintes argumentos - coordenadas x e y do canto superior esquerdo do retângulo, a largura e a altura do retângulo. Insira a seguinte instrução no applet:
Os retângulos cm cantos arredondados exigem os métodos drawRoundRect() e fillRoundRect() que recebem os quatro primeiros argumentos que os normais, com dois argumentos incluídos no final que definem a largura e a altura da área onde os cantos são arredondados, insira a seguinte instrução no applet:
screen.drawRoundRect(182, 61, 43, 24, 10, 8);
Podem ser desenhados com os métodos drawPolygon() e fillPolygon(), onde são necessárias as coordenadas x, y de cada ponto. São considerados como uma série de linhas unidas, onde ficam declarados o início e o fim de cada uma. Adicione as seguintes instruções ao método paint() do applet Map para ver os polígonos em ação :
Essa forma segue a mesma novela das formas anteriores, possui os métodos drawOval() e fillOval() usados para desenhar círculos e elipses, possuem os quatro argumentos que definem as coordenadas x e y, a largura e a altura. Inclua as seguintes instruções para o applet:
Exemplo - Formato de uma carinha através dos círculos preenchidos
De todas as formas de desenho, os arcos são os mais complexos de se construir, possuindo seis argumentos - as coordenadas x e y, a largura e a altura da elipse, o ângulo em que se deve iniciar o arco e o número de graus percorrido pelo arco. Verifique a sintaxe para esses métodos através do código completo do programa Map.java :
screen.drawLine(185,80,222,80); //linha
screen.drawRect(2, 2, 345, 345);//retângulo
screen.drawRoundRect(182,61,43,24,10,8);//retangulo arredondado
screen.fillOval(235,140,15,15);//círculo preenchido
screen.drawArc(ax, ay, 10, 10, 0, -180);//Arco
Exemplo- Utilização das formas através de um mapa
Os objetos da classe java.awt.Font são usados para se utilizar o método drawString() com diferentes fontes. Os objetos Font representam o nome, o estilo e o tamanho em pontos de uma fonte. Outra classe, FontMetrics, fornece métodos para se determinar o tamanho dos que caracteres que estão sendo apresentados com uma fonte específica, o que pode ser usado para detalhes com formatação e centralização do texto.
Um objeto fonte é criado enviando-se três argumentos para o seu construtor :
Nome - pode ser específico como as fontes internas da linguagem Java: TimesRoman, Helvetica, Courier, Dialog e DialogInput;
Estilo - podem ser definidos como Font.PLAIN, Font.BOLD e Font.ITALIC;
O tamanho em pontos da fonte.
As fontes apresentam, portanto, a seguinte sintaxe :
Font f = new Font("Dialog", Font.ITALIC, 36);
Depois é só definir a fonte atual através do método setFont() que segue a sintaxe:
O applet SoLong apresenta um string no centro da janela Applet, usando FontMetrics para medir a largura do string com a fonte atual
public class SoLong extends java.applet.Applet {
Font f = new Font("Courier", Font.BOLD, 18);
String s = "So long, and thanks for all the fish.";
int x = (size().width - fm.stringWidth(s)) / 2;
int y = size().height / 2;
screen.drawString(s, x, y);
Utilização das fontes através do applet SoLong
O método size() pode não estar compatível com a versão 1.2, se durante a compilação ou execução do programa houver alguma rejeição referente a esse método, basta substituí-lo pelo método getSize().
As classes Color e ColorSpace do pacote java.awt pode ser usadas para tornar seus applets e aplicativos mais coloridos. Com essas classes, podem ser definidas a cor atual e ser usada nas operações de desenho, bem como a cor de fundo de um applet e de outras janelas. Também podem ser convertidas uma cor de um sistema de descrição de cores para outro.
Por definição, Java usa cores de acordo com um sistema de definição de cores chamado RGB ( essas letras provém das palavras Red, Green e Blue). Cada um dos três componentes pode ser representado por um inteiro de 0 a 255. Como será visto posteriormente no quadro de cores.
A cor atual do desenho é designada pelo método setColor() da classe Graphics. Uma forma de definir a cor é usando uma das cores padrão disponíveis, como as variáveis de classe na classe Color que apresentam os seguintes parâmetros :
black(0,0,0)
darkGray(64,64,64)
orange(255,200,0)
pink(255,175,175)
gray(128,128,128)
green(0,255,00)
white(255,255,255)
lightGray(192,192,192)
Tabela -- Cores para applets
A instrução a seguir define a cor atual do objeto screen usando as variáveis de classe padrão:
screen.setColor(Color.orange);
Para criar um objeto cor com definições próprias, deve ser introduzido um código semelhante a esse:
Color novacor = new Color(255,204,102);
screen.setColor(novacor);
O método setBackground() define a cor de fundo de uma janela e o método setForeground() altera a cor de um componente de interface como um botão ou uma janela. Esses métodos recebem como argumento o objeto cor.
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
public janelaDesenho2() {
setTitle("Janela e desenho 2");
int x=startPos;
int y=startPos;
int finalPos = Math.min(d.width, d.height)-tamanho;
g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
y += incremento;
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.drawString("...pronto!", 100, 40);
janelaDesenho2 j = new janelaDesenho2();
Postado por Tiago Rafael às 15:57
Anônimo 28 de agosto de 2008 17:16
Muito bom esse tópico, mas cara, eu gostaria de aumentar a espessura da linha! é possível? ou é sempre 1?
LordTiago 3 de setembro de 2008 21:52
A espessura da linha é simples amigo,
soh me desculpe a demora para postar, pois ando estudando muito e tenho tido pouco tempo pra atualizar,
mas qualquer coisa deixe o email tbm, pra ficar mais fácil de eu entrar em contato.
A espessura vc define através da evocação da classe Basic Stroke.
Bastando executar o seguinte:
BasicStroke(20.0f));
Ou seja, eu instancio um objeto da classe Graphics2D, que vai herdar uma porrada de métodos. Entre eles o setStroke, onde dentro dele eu chamo a classe BasicStroke com o segundo parâmetro da documentação do JDK para Java 1.6
Dentro dela escolho o tamanho
Ex: 15.0f
Depois desenho um retangulo ou uma linha através do objeto instanciado da graphics2D.
Muito fácil neh?
Ícaro 26 de setembro de 2008 09:38
Valeu aí pelas dicas do JAVA tava precisando disto mesmo.
Tu sabe como posso usar as bibliotecas de java para calcular logarítimos, expoentes?
LordTiago 26 de setembro de 2008 17:54
para importar funções matemáticas em java, basta na colocar na primeira linha da classe o seguinte código: