Problema em rotacionar com Polygon

4 de fevereiro de 2013 7 respostas

geazy 4 de fevereiro de 2013

package geom;

import java.awt.Polygon;
import java.awt.geom.Point2D;

public class Estrela
{

    protected static final Point2D.Double[] ponto = new Point2D.Double[9];
    protected static Polygon estrela = new Polygon();
    protected static double x, y, e = 1.0, grau = 0.0;
    protected static double meioPoligonoX = 0.0, meioPoligonoY = 0.0;

    protected static void alteraEstado()
    {
        ponto[8] = new Point2D.Double(57.0D + x, 57.0D + y);
        meioPoligonoX = ponto[8].x;
        meioPoligonoY = ponto[8].y;
        ponto[0] = new Point2D.Double((((0.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((57.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[1] = new Point2D.Double((((43.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((43.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[2] = new Point2D.Double((((57.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((0.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[3] = new Point2D.Double((((71.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((43.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[4] = new Point2D.Double((((114.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((57.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[5] = new Point2D.Double((((71.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((71.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[6] = new Point2D.Double((((57.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((114.0 + y) - ponto[8].y) * e) + ponto[8].y);
        ponto[7] = new Point2D.Double((((43.0 + x) - ponto[8].x) * e) + ponto[8].x,
                (((71.0 + y) - ponto[8].y) * e) + ponto[8].y);
        rotaciona();
    }

    protected static void rotaciona()
    {
        double auy, aux;
        for (int i = 0; i &lt; ponto.length - 1; i++)
        {
            aux = ponto[i].x - meioPoligonoX;
            auy = ponto[i].y - meioPoligonoY;
            aux = (aux * Math.cos(Math.toRadians(grau))) - (auy * Math.sin(Math.toRadians(grau)));
            auy = (auy * Math.cos(Math.toRadians(grau))) + (aux * Math.sin(Math.toRadians(grau)));
            aux += meioPoligonoX;
            auy += meioPoligonoY;
            ponto[i] = new Point2D.Double(aux,auy);
        }
    }

    public static void desenhaStar()
    {
        int pontosX[] = new int[ponto.length - 1];
        int pontosY[] = new int[ponto.length - 1];
        for (int i = 0; i &lt; ponto.length - 1; i++)
        {
            pontosX[i] = (int) ponto[i].x;
            pontosY[i] = (int) ponto[i].y;
        }
        estrela = new Polygon(pontosX, pontosY, ponto.length - 1);
    }
}

gostaria da visao experiente de vcs para ver o meu erro, pois estou chamando este poligono e o desenhando num painel com Graphics. mas o problema e q na hora de rotacionar, ele se comporta como se fosse 3d e rotaciona nao so de coma pra baixo como de um lado pra outro dando a impressao de uma animacao 3d.

7 Respostas

rof20004 4 de fev. de 2013

Voce nao quer ki ele rotacione ? é isso ?

geazy 4 de fev. de 2013

nao, nao, pelo contrario. mas ja resolvi. faz 10 minutos , hehe. vlw

rof20004 4 de fev. de 2013

ok, coloque no seu topico como resolvido =D

geazy 4 de fev. de 2013

na verdade esse é o centro da estrela. Ja q necessita setar o centro para 0 e depois voltar para a posicao.

entanglement 5 de fev. de 2013

Geazy-san, eu sou muito preguiçoso e deixo para o Java resolver os problemas para mim. Se aprender o que é “AffineTransform” (procure o javadoc), você resolve esses problemas sem fazer muitas contas.

Vou deixar um código abaixo para você ver.

package guj;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.LayoutManager;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.Path2D;

import javax.swing.JPanel;

public class StarPanel extends JPanel {

    public StarPanel() {
        // TODO Auto-generated constructor stub
    }

    public StarPanel(LayoutManager layout) {
        super(layout);
        // TODO Auto-generated constructor stub
    }

    public StarPanel(boolean isDoubleBuffered) {
        super(isDoubleBuffered);
        // TODO Auto-generated constructor stub
    }

    @Override
    protected void paintComponent(Graphics g) {
        // TODO Auto-generated method stub
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setRenderingHint (RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        Dimension d = this.getSize();
        double m = Math.min(d.width, d.height)/2;
        AffineTransform at = new AffineTransform (m, 0, 0, -m, d.width/2, d.height/2);
//        AffineTransform at = AffineTransform.getTranslateInstance(d.width/2, d.height/2);
//        at.concatenate(AffineTransform.getScaleInstance(m, -m));
        g2d.setTransform(at);
        Stroke st = new BasicStroke (0.01f);
        g2d.setStroke (st);
        // Drawing the axes
        Line2D xaxis = new Line2D.Double (-1, 0, +1, 0);
        Line2D yaxis = new Line2D.Double (0, -1, 0, +1);
        g2d.draw(xaxis);
        g2d.draw(yaxis);
        // Drawing a polygon
        int n =5;
        Path2D p2d = new Path2D.Double();
        p2d.moveTo(0, 1);
        for (int i = 0; i <= n; ++i) {
            double x = Math.sin(4 * Math.PI * i / n);
            double y = Math.cos(4 * Math.PI * i / n);
            p2d.lineTo(x, y);
        }
        g2d.draw(p2d);
        // Translating it 0.25, 0.25
        at.concatenate(AffineTransform.getTranslateInstance (0.25, 0.25));
        g2d.setTransform(at);
        g2d.setPaint(Color.GREEN);
        g2d.draw(p2d);
        // Drawing the same polygon but rotating it 360/n/2 degrees
        at.concatenate(AffineTransform.getRotateInstance(Math.PI/n));
        g2d.setTransform(at);
        g2d.setPaint(Color.RED);
        g2d.draw(p2d);
        g2d.dispose();
    }

    public StarPanel(LayoutManager layout, boolean isDoubleBuffered) {
        super(layout, isDoubleBuffered);
        // TODO Auto-generated constructor stub
    }

}

package guj;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

public class StarPanelJFrame extends JFrame {

    private JPanel contentPane;
    private StarPanel panel;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    StarPanelJFrame frame = new StarPanelJFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public StarPanelJFrame() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(0, 0, 0, 0));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);
        contentPane.add(getPanel(), BorderLayout.CENTER);
    }

    private StarPanel getPanel() {
        if (panel == null) {
            panel = new StarPanel();
        }
        return panel;
    }
}

geazy 5 de fev. de 2013

hehe, eu tb, mas era exigido fazer assim. mas tudo bem vlw

WellingtonRamos 4 de fev. de 2013

Aqui o javadoc diz:
<blockquote><div class="quote-author">JavaDoc:</div>
Constructs and initializes a Polygon from the specified parameters.
Parameters:
xpoints - an array of X coordinates
ypoints - an array of Y coordinates
[b]npoints - the total number of points in the Polygon[/b]
</blockquote>
Faz muito tempo que não utilizo essa classe, mas o que indica em npoints seria ponto.length mesmo (sem o -1). Não seria?

Outra dúvida, Todos os pontos são calculados a partir do ponto[8]?

Aqui o javadoc diz:

Faz muito tempo que não utilizo essa classe, mas o que indica em npoints seria ponto.length mesmo (sem o -1). Não seria?

Outra dúvida, Todos os pontos são calculados a partir do ponto[8]?

Criado 4 de fevereiro de 2013

Ultima resposta 4 de fev. de 2013

Respostas 7

Participantes 4

7 Respostas

Topicos relacionados