title: How to rotate a polygon/points around a point in Java
body: <p>I've been trying to rotate a polygon around a specified center point but everything I've tried has failed miserably. I've googled for example and found many but not a single one seems to work.</p>
  
  <p>The result I'm trying to replicate is similar with the first answer to this </p>
  
  <p><a href="https://stackoverflow.com/questions/3405799">How to rotate an image gradually in Swing?</a></p>
  
  <p>The difference is that I need the polygon to actually rotate, just drawing it in an angle won't cut it. (it's for simple physics modelling)</p>
  
  <p>Here's my code, with several different methods I've tried to implement</p>
  
  <pre><code>import java.awt.Color;
  import java.awt.Graphics;
  import java.awt.Point;
  import java.awt.Polygon;
  import java.awt.Shape;
  import java.awt.geom.AffineTransform;
  import java.util.Timer;
  import java.util.TimerTask;
  import javax.swing.JPanel;
  
  public class rotationPanel extends JPanel {
  
      private static final int SIZE = 500;
      private static final Shape outline = makeShape();
  
      Point p;
      Point p2;
      Point p3;
      Point p4;
      Point[] points;
      Point[] npoints;
  
      Point center;
      Polygon poly;
  
      double angle;
  
      Timer timer;
      long start;
      long sleepTime;
      static int runTime;
  
      public rotationPanel(){
          setSize(500,500);
          setBackground(Color.DARK_GRAY);
          setVisible(true);
  
          runTime = 100;  //ms
  
          start = 0;
          sleepTime = 0;
          timer = new Timer();
  
          center = new Point(250,250);
  
          p = new Point(200,200);
          p2 = new Point(150,150);
          p3 = new Point(250,150);
          p4 = new Point(200,100);
  
          /*
          points = new Point[4];
          points[0]=p;
          points[1]=p2;
          points[2]=p3;
          points[3]=p4;
  
          npoints = new Point[4];
          npoints[0]=p;
          npoints[1]=p2;
          npoints[2]=p3;
          npoints[3]=p4;
  
          poly = new Polygon();
          */
  
      }
  
      public void mainloop(){
          start= System.currentTimeMillis();
  
          //rotate(points,2);
  
          p = rotatePoint(p,center);
          p2 = rotatePoint(p2,center);
          p3 = rotatePoint(p3,center);
          p4 = rotatePoint(p4,center);
  
          repaint();
  
          sleepTime = runTime -(System.currentTimeMillis()-start);
          System.out.println("Looped. Sleeping for:" +sleepTime+"ms");
  
          if(sleepTime&gt;0)
              timer.schedule(new loop(), sleepTime);
          else
              mainloop();
  
      }
  
       private static Shape makeShape() {
              AffineTransform at = new AffineTransform();
              at.translate(SIZE/2, SIZE/2);
              at.scale(20, 20);
              at.rotate(Math.toRadians(35));
              return at.createTransformedShape(initPoly());       
          }
  
          /** Create a U shaped outline. */
          private static Polygon initPoly() {
              Polygon poly = new Polygon();
              poly.addPoint( 1,  0);
              poly.addPoint( 1, -2);
              poly.addPoint( 2, -2);
              poly.addPoint( 2,  1);
              poly.addPoint(-2,  1);
              poly.addPoint(-2, -2);
              poly.addPoint(-1, -2);
              poly.addPoint(-1,  0);
              return poly;
          }
  
      public void rotatePoint(Point pt, double rotationAngle){
  
          AffineTransform.getRotateInstance
          (Math.toRadians(rotationAngle), center.x, center.y)
                  .transform(pt,pt);          
      }
  
      public Point rotatePoint(Point pt, Point center)
      {
          angle = (Math.toRadians(150));
          double cosAngle = Math.cos(angle);
          double sinAngle = Math.sin(angle);
  
          pt.x = center.x + (int) ((pt.x-center.x)*cosAngle-(pt.y-center.y)*sinAngle);
          pt.y = center.y + (int) ((pt.x-center.x)*sinAngle+(pt.y-center.y)*cosAngle);
          return pt;
      }
  
      public void rotate(Point[] pts, int angle){
  
          AffineTransform.getRotateInstance
          (Math.toRadians(angle), center.x, center.y)
                  .transform(pts,0,npoints,0,4);
  
          points = new Point[4];
          points[0]=npoints[0];
          points[1]=npoints[1];
          points[2]=npoints[2];
          points[3]=npoints[3];
  
      }
  
      public void paintComponent(Graphics g) {
             super.paintComponent(g);  
  
             g.setColor(Color.BLUE);
             g.fillRect(center.x-4, center.y-4, 8, 8);
  
             g.setColor(Color.YELLOW);
             //g.fillRect(p.x-4, p.y-4, 8, 8);
             //g.fillRect(p2.x-4, p2.y-4, 8, 8);
             //g.fillRect(p3.x-4, p3.y-4, 8, 8);
             //g.fillRect(p4.x-4, p4.y-4, 8, 8);
  
             g.fillRect(p.x, p.y, 2, 2);
             g.fillRect(p2.x, p2.y, 2, 2);
             g.fillRect(p3.x, p3.y, 2, 2);
             g.fillRect(p4.x, p4.y, 2, 2);
      }
  
      class loop extends TimerTask{
  
          public void run() {
              mainloop();         
          }
  
      }
  
  }
  </code></pre>