Tracer une ligne avec une flèche en Java

Question

Quelqu'un peut-il me guider pour coder la ligne de flèche dans une direction différente. wa et wl est positif le rectangle sera sur le dessus de l'axe des x. L'exemple ci-dessous montre si wl est négatif et wa est positif. Le code ci-dessous montre comment je code la forme du rectangle. x1 est la variable indiquant où commencer à l'axe x. e1 est la longueur de la forme, wa1 et wl1 est la hauteur. wsign pour déterminer la hauteur wa1 ou wl1 devrait afficher du côté négatif ou positif.

 if (Math.abs(wl1) > Math.abs(wa1)) { 
      y_scale = (load_y0 - 40)/(double) Math.abs(wl1); 
     } else { 
      y_scale = (load_y0 - 40)/(double) Math.abs(wa1); 
     } 
     g.drawLine((int) ((double) x0 + x1 * x_scale), (int) (load_y), 
        (int) ((double) x0 + x1 * x_scale), 
        (int) (load_y + (wa1 * y_scale) * -1)); 
      g.drawLine((int) ((double) x0 + (x1 + e1) * x_scale), 
        (int) (load_y), (int) ((double) x0 + (x1 + e1) 
          * x_scale), (int) (load_y + (wl1 * y_scale) 
          * -1)); 

      g.drawLine((int) ((double) x0 + x1 * x_scale), 
        (int) (load_y + (wa1 * y_scale * -1)), 
        (int) ((double) x0 + (x1 + e1) * x_scale), 
        (int) (load_y + (wl1 * y_scale) * -1)); 

Answer 1

Voici une routine simple (adoptée à partir here) pour le dessin des flèches arbitraires:

import static java.awt.geom.AffineTransform.*; 
import java.awt.*; 
import java.awt.geom.AffineTransform; 
import javax.swing.*; 

public class Main { 
    public static void main(String args[]) { 
     JFrame t = new JFrame(); 
     t.add(new JComponent() { 

      private final int ARR_SIZE = 4; 

      void drawArrow(Graphics g1, int x1, int y1, int x2, int y2) { 
       Graphics2D g = (Graphics2D) g1.create(); 

       double dx = x2 - x1, dy = y2 - y1; 
       double angle = Math.atan2(dy, dx); 
       int len = (int) Math.sqrt(dx*dx + dy*dy); 
       AffineTransform at = AffineTransform.getTranslateInstance(x1, y1); 
       at.concatenate(AffineTransform.getRotateInstance(angle)); 
       g.transform(at); 

       // Draw horizontal arrow starting in (0, 0) 
       g.drawLine(0, 0, len, 0); 
       g.fillPolygon(new int[] {len, len-ARR_SIZE, len-ARR_SIZE, len}, 
           new int[] {0, -ARR_SIZE, ARR_SIZE, 0}, 4); 
      } 

      public void paintComponent(Graphics g) { 
       for (int x = 15; x < 200; x += 16) 
        drawArrow(g, x, x, x, 150); 
       drawArrow(g, 30, 300, 300, 190); 
      } 
     }); 

     t.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     t.setSize(400, 400); 
     t.setVisible(true); 
    } 
} 

Résultat:

Answer 2

échantillon simple flèche

/** 
* @param fromPoint end of the arrow 
* @param rotationDeg rotation angle of line 
* @param length arrow length 
* @param wingsAngleDeg wingspan of arrow 
* @return Path2D arrow shape 
*/ 
public static Path2D createArrowForLine(
       Point2D fromPoint, 
       double rotationDeg, 
       double length, 
       double wingsAngleDeg) { 

     double ax = fromPoint.getX(); 
     double ay = fromPoint.getY(); 

     double radB = Math.toRadians(-rotationDeg + wingsAngleDeg); 
     double radC = Math.toRadians(-rotationDeg - wingsAngleDeg); 

     Path2D resultPath = new Path2D.Double(); 
     resultPath.moveTo(length * Math.cos(radB) + ax, length * Math.sin(radB) + ay); 
     resultPath.lineTo(ax, ay); 
     resultPath.lineTo(length * Math.cos(radC) + ax, length * Math.sin(radC) + ay); 
     return resultPath; 
    }