posible - dibujar rombo en java graphics

Cómo dibujar líneas en Java

Question

Me pregunto si hay una función en Java que pueda dibujar una línea desde las coordenadas (x1, x2) a (y1, y2).

Lo que quiero es hacer algo como esto:

drawLine(x1, x2, x3, x4);

Y quiero poder hacerlo en cualquier momento en el código, haciendo aparecer varias líneas a la vez.

He intentado hacer esto:

public void paint(Graphics g){
   g.drawLine(0, 0, 100, 100);
}

Pero esto no me permite controlar cuándo se usa la función y no puedo averiguar cómo llamarla varias veces.

Espero que entiendas lo que quiero decir!

PS Quiero crear un sistema de coordenadas con muchas coordenadas.

Answer 1

Almacena las líneas en algún tipo de lista. Cuando llegue el momento de pintarlos, itere la lista y dibuje cada uno. Me gusta esto:

DrawLines

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.geom.Line2D;

import javax.swing.JOptionPane;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;

import java.util.ArrayList;
import java.util.Random;

class DrawLines {

    public static void main(String[] args) {

        Runnable r = new Runnable() {
            public void run() {
                LineComponent lineComponent = new LineComponent(400,400);
                for (int ii=0; ii<30; ii++) {
                    lineComponent.addLine();
                }
                JOptionPane.showMessageDialog(null, lineComponent);
            }
        };
        SwingUtilities.invokeLater(r);
    }
}

class LineComponent extends JComponent {

    ArrayList<Line2D.Double> lines;
    Random random;

    LineComponent(int width, int height) {
        super();
        setPreferredSize(new Dimension(width,height));
        lines = new ArrayList<Line2D.Double>();
        random = new Random();
    }

    public void addLine() {
        int width = (int)getPreferredSize().getWidth();
        int height = (int)getPreferredSize().getHeight();
        Line2D.Double line = new Line2D.Double(
            random.nextInt(width),
            random.nextInt(height),
            random.nextInt(width),
            random.nextInt(height)
            );
        lines.add(line);
        repaint();
    }

    public void paintComponent(Graphics g) {
        g.setColor(Color.white);
        g.fillRect(0, 0, getWidth(), getHeight());
        Dimension d = getPreferredSize();
        g.setColor(Color.black);
        for (Line2D.Double line : lines) {
            g.drawLine(
                (int)line.getX1(),
                (int)line.getY1(),
                (int)line.getX2(),
                (int)line.getY2()
                );
        }
    }
}

Captura de pantalla

Answer 2

Construí toda una clase de métodos para dibujar puntos, líneas, rectángulos, círculos, etc. Lo diseñé para tratar la ventana como un trozo de papel cuadriculado donde el origen no tiene que estar en la parte superior izquierda y los valores y aumentan. a medida que subes Así es como trazo líneas:

public static void drawLine (double x1, double y1, double x2, double y2)
{       
    ((Graphics2D)g).draw(new Line2D.Double(x0+x1*scale, y0-y1*scale, x0+x2*scale, y0-y2*scale));
}

En el ejemplo anterior, (x0, y0) representa el origen en las coordenadas de la pantalla y la scale es un factor de escala. Los parámetros de entrada deben suministrarse como coordenadas de gráfico, no de pantalla. No hay repaint() siendo llamado. Puede guardar eso hasta que haya dibujado todas las líneas que necesita.

Se me ocurre que alguien podría no querer pensar en términos de papel cuadriculado:

    ((Graphics2D)g).draw(new Line2D.Double(x1, y1, x2, y2));

Note el uso de Graphics2D . Esto nos permite dibujar un objeto Line2D utilizando dobles en lugar de ints. Además de otras formas, mi clase tiene soporte para el dibujo en perspectiva 3D y varios métodos de conveniencia (como dibujar un círculo centrado en un determinado punto dado un radio). Si alguien está interesado, me encantaría compartir más de esta clase.

Answer 3

En tu clase deberías tener:

public void paint(Graphics g){
   g.drawLine(x1, y1, x2, y2);
}

Luego, en el código, si es necesario, cambiará x1, y1, x2, y2 y llamará repaint(); .

Answer 4

Necesitas crear una clase que amplíe el componente. Allí puede anular el método de pintura y poner su código de pintura en:

package blah.whatever;

import java.awt.Component;
import java.awt.Graphics;

public class TestAWT extends Component {

/** @see java.awt.Component#paint(java.awt.Graphics) */
@Override
public void paint(Graphics g) {
    super.paint(g);
    g.drawLine(0,0,100,100);
    g.drawLine(10, 10, 20, 300);
    // more drawing code here...
}

}

Ponga este componente en la GUI de su aplicación. Si está utilizando Swing, necesita extender JComponent y anular paintComponent, en su lugar.

Como mencionó Helios, el código de pintura le dice al sistema cómo se ve su componente. El sistema solicitará esta información (llame a su código de pintura) cuando piense que debe ser (re) pintada, por ejemplo, si una ventana se mueve delante de su componente.

Answer 5

Para darte una idea:

public void paint(Graphics g) {
   drawCoordinates(g);
}

private void drawCoordinates(Graphics g) {

  // get width & height here (w,h)

  // define grid width (dh, dv)

  for (int x = 0; i < w; i += dh) {
    g.drawLine(x, 0, x, h);
  }
  for (int y = 0; j < h; j += dv) {
      g.drawLine(0, y, w, y);
  }
}

Answer 6

Para responder a su pregunta original, es (x1, y1) a (x2, y2) .

Por ejemplo,

Esto es para dibujar una línea horizontal:

g.drawLine( 10, 30, 90, 30 );

vs

Esto es para dibujar una línea vertical:

g.drawLine( 10, 30, 10, 90 );

Espero que ayude.

Answer 7

Puede utilizar el método getGraphics del componente en el que desea dibujar. Esto, a su vez, debería permitirle dibujar líneas y otras cosas que están disponibles a través de la clase Graphics

Answer 8

Tengo entendido que está utilizando Java AWT API para dibujar. El método de pintura se invoca cuando el control necesita volver a pintar. Y estoy bastante seguro de que proporciona en el argumento de los gráficos qué rectángulo es el que necesita volver a pintar (para evitar volver a dibujar todo).

Entonces, si está presentando una imagen fija, simplemente dibuje lo que necesite en ese método.

Si está animando, asumo que puede invalidar alguna región y el método de pintura se invocará automáticamente. Por lo tanto, puede modificar el estado, invalidar la llamada y se volverá a llamar.

Answer 9

Un ejemplo muy simple de un componente de swing para dibujar líneas. Mantiene internamente una lista con las líneas que se han agregado con el método addLine. Cada vez que se agrega una nueva línea, se invoca el repintado para informar al subsistema gráfico que se requiere una nueva pintura.

La clase también incluye algún ejemplo de uso.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class LinesComponent extends JComponent{

private static class Line{
    final int x1; 
    final int y1;
    final int x2;
    final int y2;   
    final Color color;

    public Line(int x1, int y1, int x2, int y2, Color color) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
        this.color = color;
    }               
}

private final LinkedList<Line> lines = new LinkedList<Line>();

public void addLine(int x1, int x2, int x3, int x4) {
    addLine(x1, x2, x3, x4, Color.black);
}

public void addLine(int x1, int x2, int x3, int x4, Color color) {
    lines.add(new Line(x1,x2,x3,x4, color));        
    repaint();
}

public void clearLines() {
    lines.clear();
    repaint();
}

@Override
protected void paintComponent(Graphics g) {
    super.paintComponent(g);
    for (Line line : lines) {
        g.setColor(line.color);
        g.drawLine(line.x1, line.y1, line.x2, line.y2);
    }
}

public static void main(String[] args) {
    JFrame testFrame = new JFrame();
    testFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    final LinesComponent comp = new LinesComponent();
    comp.setPreferredSize(new Dimension(320, 200));
    testFrame.getContentPane().add(comp, BorderLayout.CENTER);
    JPanel buttonsPanel = new JPanel();
    JButton newLineButton = new JButton("New Line");
    JButton clearButton = new JButton("Clear");
    buttonsPanel.add(newLineButton);
    buttonsPanel.add(clearButton);
    testFrame.getContentPane().add(buttonsPanel, BorderLayout.SOUTH);
    newLineButton.addActionListener(new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            int x1 = (int) (Math.random()*320);
            int x2 = (int) (Math.random()*320);
            int y1 = (int) (Math.random()*200);
            int y2 = (int) (Math.random()*200);
            Color randomColor = new Color((float)Math.random(), (float)Math.random(), (float)Math.random());
            comp.addLine(x1, y1, x2, y2, randomColor);
        }
    });
    clearButton.addActionListener(new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent e) {
            comp.clearLines();
        }
    });
    testFrame.pack();
    testFrame.setVisible(true);
}

}

Answer 10

a simple line , after that you can see also a doted line 

import java.awt.*;

import javax.swing.*;

import java.awt.Graphics.*;

import java.awt.Graphics2D.*;

import javax.swing.JFrame;

import javax.swing.JPanel;

import java.awt.BasicStroke;

import java.awt.Event.*;

import java.awt.Component.*;

import javax.swing.SwingUtilities;


/**
 *
 * @author junaid
 */
public class JunaidLine extends JPanel{


//private Graphics Graphics;

private void doDrawing(Graphics g){

Graphics2D g2d=(Graphics2D) g;

float[] dash1 = {2f,0f,2f};

g2d.drawLine(20, 40, 250, 40);

BasicStroke bs1 = new BasicStroke(1,BasicStroke.CAP_BUTT,

                    BasicStroke.JOIN_ROUND,1.0f,dash1,2f);

g2d.setStroke(bs1);

g2d.drawLine(20, 80, 250, 80);

    }

@Override

public void paintComponent(Graphics g){

super.paintComponent( g);

doDrawing(g);

}


}

class BasicStrokes extends JFrame{

public  BasicStrokes(){

initUI();

}

private void initUI(){

setTitle("line");

setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

add(new JunaidLine());

setSize(280,270);

setLocationRelativeTo(null);

}

/**

* @param args the command line arguments

*/

public static void main(String[] args) {


SwingUtilities.invokeLater(new Runnable(){   

@Override

public void run(){

BasicStrokes bs = new BasicStrokes();

bs.setVisible(true);

}                

});

}


}