Comment dessiner des lignes en Java
Je me demande s'il existe une fonction en Java capable de tracer une ligne entre les coordonnées (x1, x2) et (y1, y2)?
Ce que je veux, c'est faire quelque chose comme ça:
drawLine(x1, x2, x3, x4);
Et je veux pouvoir le faire à tout moment dans le code, en faisant apparaître plusieurs lignes à la fois.
J'ai essayé de faire ceci:
public void Paint(Graphics g){
g.drawLine(0, 0, 100, 100);
}
Mais cela ne me permet pas de savoir quand la fonction est utilisée et je n'arrive pas à comprendre comment l'appeler plusieurs fois.
J'espère que vous comprenez ce que je veux dire!
P.S. Je veux créer un système de coordonnées avec plusieurs coordonnées.
Un exemple très simple d'un composant swing pour dessiner des lignes. Il conserve en interne une liste avec les lignes qui ont été ajoutées avec la méthode addLine. Chaque fois qu'une nouvelle ligne est ajoutée, repeindre est appelé pour informer le sous-système graphique qu'une nouvelle peinture est requise.
La classe comprend également des exemples d'utilisation.
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);
}
}
Stockez les lignes dans un type de liste. Lorsque vient le temps de les peindre, parcourez la liste et dessinez-les. Comme ça:
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()
);
}
}
}
Capture d'écran
Vous devez créer une classe qui étend Component. Là, vous pouvez remplacer la méthode Paint et mettre votre code de peinture dans:
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...
}
}
Placez ce composant dans l'interface graphique de votre application. Si vous utilisez Swing, vous devez plutôt étendre JComponent et remplacer paintComponent.
Comme Helios l’a mentionné, le code de dessin indique au système l’apparence de votre composant. Le système vous demandera cette information (appelez votre code de dessin) lorsqu'il pense qu'il est nécessaire de le (re) peindre, par exemple si une fenêtre est déplacée devant votre composant.
Dans votre classe, vous devriez avoir:
public void Paint(Graphics g){
g.drawLine(x1, y1, x2, y2);
}
Puis dans le code, si nécessaire, vous changerez x1, y1, x2, y2 et appelez repaint();.
Je comprends que vous utilisez l’API Java AWT pour dessiner. La méthode Paint est appelée lorsque le contrôle doit être repeint. Et je suis sûr que l’argument Graphics indique quel rectangle est celui qui doit être repeint (pour éviter de tout redessiner).
Donc, si vous présentez une image fixe, vous ne dessinez que ce dont vous avez besoin avec cette méthode.
Si vous animez, je suppose que vous pouvez invalider une région et que la méthode Paint sera invoquée automatiquement. Ainsi, vous pouvez modifier l’état, appeler invalidate et l’appel sera rappelé.
Pour vous donner une idée:
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);
}
}
Pour répondre à votre question initiale, c’est (x1, y1) à (x2, y2).
Par exemple,
Ceci est pour tracer une ligne horizontale:
g.drawLine( 10, 30, 90, 30 );
contre
Ceci est pour tracer une ligne verticale:
g.drawLine( 10, 30, 10, 90 );
J'espère que ça aide.
J'ai construit toute une classe de méthodes pour dessiner des points, des lignes, des rectangles, des cercles, etc. Je l'ai conçue pour traiter la fenêtre comme un morceau de papier graphique où l'Origine n'a pas besoin d'être en haut à gauche et où les valeurs y augmentent comme vous montez. Voici comment je trace des lignes:
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));
}
Dans l'exemple ci-dessus, (x0, y0) représente l'origine en coordonnées d'écran et scale est un facteur de mise à l'échelle. Les paramètres d'entrée doivent être fournis sous forme de coordonnées graphiques, pas de coordonnées d'écran. Il n'y a pas de repaint() appelé. Vous pouvez enregistrer jusqu'à ce que vous ayez dessiné toutes les lignes dont vous avez besoin.
Il me semble que quelqu'un pourrait ne pas vouloir penser en termes de papier millimétré:
((Graphics2D)g).draw(new Line2D.Double(x1, y1, x2, y2));
Notez l'utilisation de Graphics2D. Cela nous permet de dessiner un objet Line2D en utilisant des doubles au lieu d’int. Outre les autres formes, ma classe prend en charge le dessin en perspective 3D et plusieurs méthodes pratiques (par exemple, dessiner un cercle centré à un certain point sur un rayon donné). Si quelqu'un est intéressé, je serais heureux de partager davantage de cette classe.
Vous pouvez utiliser la méthode getGraphics du composant sur lequel vous souhaitez dessiner. Cela devrait vous permettre de tracer des lignes et de rendre d’autres éléments accessibles via la classe Graphics
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);
}
});
}
}