Desenhos no Java

Gente possuo uma aplicação aqui que estou brincando com ela, eu tenho uma opção no programa que se chama “Eraser”, que conforme o usuario passa, ele pinta por cima da imagem…

Explicando o que está acontecendo:

  1. Possuo uma pilha com todos os tipos de elementos que foram criados, todos mesmo…

  2. Tenho uma classe que se chama Eraser, nessa classe tem uma Lista de Points (List<Points> ).

2.1) Quando se clica na tela, cria-se um novo Objeto do tipo Eraser.

2.2) Enquanto se estiver arrastando o mouse, ele vai criando um “new Point” e inserindo na lista do Objeto Eraser que foi criado anteriormente quando clicou na tela.

2.3) Depois que o usuario solta o mouse, ele termina essa classe do tipo Eraser…

Este processo é repetido toda ves com as mesmas ações, porém esta extremamente custoso por que quando eu chamo o metodo paintComponents(Graphics g), ele repinta toda a pilha e quando chega nos Objetos do tipo Eraser ele tem que pintar todos os Pontos que foram adicionados nas Listas dos objetos Eraser…

See it:

					for (Point j : ((Eraser) i).getEraserList()) {
						copy.fillOval((int) j.getX(), (int) j.getY(), ((Eraser) i).getSize(), ((Eraser) i).getSize());
					}

Eu infelizmente não estou conseguindo pensar numa maneira de que fique pouco custosa essa parte da Eraser aii…

Será que alguem poderia me ajudar ?

Classe da Eraser ( Borracha ):
[code]

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.image.BufferedImage;
import java.util.LinkedList;
import java.util.List;

public class Eraser implements Shape {
private Color color;
private int size;
private List<Point> eraserList;

public Eraser(Point start, int size, Color color) {
	this.color = color;
	this.size = size;
	this.eraserList = new LinkedList&lt;Point&gt;();
	ajustPreferedSize(start);
	this.eraserList.add(start);
}

public void addPoint(Point p) {
	ajustPreferedSize(p);
	this.eraserList.add(p);
}

public Color getColor() {
	return color;
}

public int getSize() {
	return size;
}

public List&lt;Point&gt; getEraserList() {
	return eraserList;
}

private void ajustPreferedSize(Point p) {
	p.move((int) (p.getX() - Math.ceil(((double) size / 2.))), (int) (p.getY() - Math.ceil(((double) size / 2.))));
}

}
[/code]

Ow que legal hein… tá fazendo uma aplicação pra desenhar ou um jogo?
O que exatamente está custoso? Sobe muita memória? O aplicativo senta a máquina?

Você está utilizando alguma estratégia de Buffer (BufferStrategy) ?

Bem esse teu objeto Eraser são os pontos que o apagador (a borracha) pintou da cor do fundo sobre
o painel.

Ou seja, teus outros objetos são desenhos e o eraser são os apagamentos de pontos destes desenhos,
ou a pintura sobre eles que no final é a mesma coisa apenas com cor distinta.

Realmente é um processo custoso. Ao arrastar o mouse são pontos e mais pontos gravados na lista do
Eraser. Ao dar repaint esses pontos tem que ser refeitos e se forem milhares, é isso que vai se repetir
milhares de vezes.

Não há outra maneira de apagar/pintar sem vc precisa repintar tudo.

Mas é muito incomum um sistema gravar a parte apagada/pintada de um desenho. O normal seria preservar
o desenho final de alguma forma e repintá-lo e partir dali. Remontar o desenho como um script é
usado apenas em caso de sistemas CAD.

Se esse tal eraser pinta, poderia substituir a coleção de pontos,
por um ponto só e fazer um loop que tratasse de preencher uma
área limitada. Tipo no Paint a latinha de tinta que preenche uma
área limitada por outra cor.

Mas no final das contas também precisa de um loop que varra a
area para todos os lados e va pintando ponto por ponto ateh
nao ter mais nada da cor anterior.

Como eu postei há algum tempo, existem 2 jeitos de se fazer as coisas:

  • Se quiser escrever um PhotoShop (editor de pixels) você deve usar um BufferedImage e o método paintComponent deve mostrar essa BufferedImage.
  • Se quiser escrever um CorelDraw (editor de figuras), você pode fazer exatamente como você já fez (listagem de Shapes).

Você está tentando escrever um PhotoShop como se fosse um CorelDraw, ou seja, não funfa.

Veja os artigos do ViniGodoy no PontoV.

Olá, desculpem mesmo a demora para dar um retorno, o que eu pensei apartir do que voces me propuseram foi o seguinte:

Como meu programa tem o famozo Ctrol-Z e o famoso Ctrol-Y, eu vou fazer da seguinte maneira:

Sempre que se desenhar uma nova forma, sera desenhado em cima da bufferedImage. Quando ocorrer um evento de Ctrol-Z || Ctrol-Y, sera deletada a bufferedImage atual, repintada toda uma nova bufferedImage mas adicionando a ultima ação ou removendo a ultima ação (Ctrol-Z || Ctrol-Y).
Assim concerteza vai ficar extremamente menos custoso o programa, mas sempre atualizando a pilha de formas a cada ação.
Concerteza vai ficar pouco custoso o progama, pois dessa menira ele n precisa repintar todaaa a pilha depois que faz qquer coisa na area de pintura, soh quando se faz o Ctrol-Z || Ctrol-Y…

Acho que O(1) para demais ações e O(n²) para os Ctrol-Z || Ctrol-Y…

Ps: Se eu falei merda me desculpem ok ?

Obs: jaboot, é um programa para desenhar, esta muito custoso porque ele ta trabalhando baseado em clicks do mouse, qquer click ele ja repinta a pilha de novo e de novo e de novo; por conta disso, esta consumindo uma memoria meio que grande e se tiver objeto do Eraser, ele repinta a pilha inteira e ainda para cada Eraser, tem uma List<Point> com todos os pontos onde foram adicionados os Draggeds, ele repinta tbm, ta O(n²²²²)… kkkkkkkkkk

entanglement , eu entendi o que voce disse, é que eu gostaria de fazer algumas funcionalidades do PS + CDR…

Obrigado pelas opniões, se alguem tiver mais ideias interessantes, não tenham medo, so falar.