Java 找到旋转的缓冲区图像的中心点

我基本上想做的是旋转一个

BufferedImage

，然后根据它的新中心点绘制它

所以，最初我会这么做

graphics.drawImage(image, x - (image.getWidth() / 2), y - (image.getHeight() / 2), this);

但是，当我使用

AffineTransform

旋转图像时，我不确定如何执行此操作

---

如果我记得在学校的基础数学课上，我需要用Cos表示X，Sin表示Y，但是我一直在用谷歌搜索一个算法，但似乎什么都找不到。

我发现了如何获得旋转点的坐标。如果

x1，y1

是原始坐标，并且

在
仿射变换处
则可以使用

Point2D point1origCoords = at.transform(new Point2D.Double(x1,y1),null);

仿射变换后，新坐标系中点的坐标将与原始坐标相同。它们保持不变，因为变换的是坐标系，所以需要对它们应用仿射变换

以下是围绕原点旋转的演示：


以及用于生成它的代码：

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Point2D;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Triangle extends JPanel {

    public void drawTriangle(Graphics2D g, 
            int x1, int y1, int x2, int y2, int x3, int y3, 
            int s, Color c, AffineTransform at) throws NoninvertibleTransformException{ 
        g.setStroke(new BasicStroke(3.0f));
        g.setPaint(c);
        int d = 10;
        g.drawLine(x1*s, y1*s, x2*s, y2*s);
        g.drawLine(x2*s, y2*s, x3*s, y3*s);
        g.drawLine(x3*s, y3*s, x1*s, y1*s);
        Ellipse2D center_of_triangle = new Ellipse2D.Double(.33*(x1+x2+x3)*s, .33*(y1+y2+y3)*s,4,4);
        g.draw(center_of_triangle);

        float dash1[] = {2.0f};
        BasicStroke dashed =
                new BasicStroke(1.0f,
                        BasicStroke.CAP_BUTT,
                        BasicStroke.JOIN_MITER,
                        10.0f, dash1, 0.0f);
        g.setStroke(dashed);

        g.drawLine(0,0,x1*s,y1*s);
        g.drawLine(0,0,x2*s,y2*s);
        g.drawLine(0,0,x3*s,y3*s);

        g.setColor(Color.black);
        Point2D point1origCoords = at.transform(new Point2D.Double(x1,y1),null);  
        Point2D point2origCoords = at.transform(new Point2D.Double(x2,y2),null);
        Point2D point3origCoords = at.transform(new Point2D.Double(x3,y3),null);
        g.drawString("("+String.format("%.2f",point1origCoords.getX())+", "
                +String.format("%.2f",point1origCoords.getY())+")",
                x1*s,y1*s+2*d);
        g.drawString("("+String.format("%.2f",point2origCoords.getX())+", "
                +String.format("%.2f",point2origCoords.getY())+")", x2*s-4*d,y2*s-d);
        g.drawString("("+String.format("%.2f",point3origCoords.getX())+", "
                +String.format("%.2f",point3origCoords.getY())+")", x3*s+d,y3*s);

        // center of the triangle
        Point2D.Double center = new Point2D.Double(.33*(x1+x2+x3), .33*(y1+y2+y3));
        Point2D centerorigCoords = at.transform(center,null);
        g.drawString("("+String.format("%.2f",centerorigCoords.getX())+", "
                +String.format("%.2f",centerorigCoords.getY())+")",
                (int)Math.round(center.x*s),(int)Math.round(center.y*s)-d);

    }

    public void drawGrid(Graphics2D g, int s) {  
        int w = getWidth();
        int h = getHeight();
        float dash1[] = {2.0f};
        BasicStroke dashed =
                new BasicStroke(1.0f,
                        BasicStroke.CAP_BUTT,
                        BasicStroke.JOIN_MITER,
                        10.0f, dash1, 0.0f);
        g.setStroke(dashed);
        g.setColor(Color.gray);

        int j = 0;
        while( j <= h ) {
            g.drawLine(0,h-j,w,h-j);
            j+=s;
        }
        j = 0;
        while( j <= w ) {
            g.drawLine(j,0,j,h);
            j+=s;
        }
    }

    public void paintComponent(Graphics g){
        final int s=20;
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(Color.black);
        Font big = new Font("Times New Roman", Font.BOLD,20);
        g2.setFont(big); 
        drawGrid(g2,s);  
        AffineTransform at = new AffineTransform();
        // no rotation
        at.rotate(Math.toRadians(0));
        g2.transform(at);
        // rotated triangle
        try {
            drawTriangle(g2,2,26,3,12,8,21,s,Color.blue,at);
        } catch (NoninvertibleTransformException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        at.rotate(Math.toRadians(-45));
        g2.transform(at);
        try {
            drawTriangle(g2,2,26,3,12,8,21,s,Color.magenta,at);
        } catch (NoninvertibleTransformException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        JFrame frame = new JFrame("Window"); //frame is the window
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Triangle panel = new Triangle(); //panel is the graphics area where we can draw

        frame.add(panel); //put the panel inside the window
        frame.setSize(600,600); //set the window size to 600x600 pixels
        frame.setVisible(true); 
    }
}

import java.awt.BasicStroke；
导入java.awt.Color；
导入java.awt.Font；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.geom.AffineTransform；
导入java.awt.geom.Ellipse2D；
导入java.awt.geom.NoninvertibleTransformException；
导入java.awt.geom.Point2D；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公共类三角形扩展JPanel{
公共空间绘制三角形（图2d、g、，
int x1，int y1，int x2，int y2，int x3，int y3，
int s，Color c，AffineTransform at）引发不可逆的TransformException{
g、 设定行程（新基本行程（3.0f））；
g、 涂料（c）；
int d=10；
g、 抽绳（x1*s、y1*s、x2*s、y2*s）；
g、 抽绳（x2*s、y2*s、x3*s、y3*s）；
g、 抽绳（x3*s、y3*s、x1*s、y1*s）；
椭圆E2D三角形的中心=新的椭圆E2D.双（.33*（x1+x2+x3）*s、.33*（y1+y2+y3）*s，4,4）；
g、 绘制（三角形的中心）；
浮点dash1[]={2.0f}；
基本行程=
新基本行程（1.0f，
基本行程。盖头，
BasicStroke.JOIN_-MITER，
10.0f，dash1，0.0f）；
g、 设定行程（虚线）；
g、 抽绳（0,0，x1*s，y1*s）；
g、 抽绳（0,0，x2*s，y2*s）；
g、 抽绳（0,0,x3*s，y3*s）；
g、 设置颜色（颜色为黑色）；
Point2D Point1OrgCoords=at.transform（新的Point2D.Double（x1，y1），null）；
Point2D Point2OrgCoords=at.transform（新的Point2D.Double（x2，y2），null）；
Point2D point3origCoords=at.transform（新的Point2D.Double（x3，y3），null）；
g、 drawString（（“+String.format”（%.2f），Point1OrgCoords.getX（））+”，“
+String.format（“%.2f”，point1origCoords.getY（））+”，
x1*s，y1*s+2*d）；
g、 drawString（“（“+String.format”（%.2f），Point2OrgCoords.getX（））+”，“
+String.format（“%.2f”，point2origCoords.getY（））+”），x2*s-4*d，y2*s-d）；
g、 drawString（“（“+String.format”（%.2f），point3origCoords.getX（））+”，“
+String.format（“%.2f”，point3origCoords.getY（））+”，x3*s+d，y3*s）；
//三角形的中心
点2D.双中心=新点2D.双（.33*（x1+x2+x3），.33*（y1+y2+y3））；
Point2D centerorigCoords=at.transform（中心，null）；
g、 抽绳（“（“+String.format”（%.2f），centerorigCoords.getX（））+”，“
+String.format（“%.2f”，centerorigCoords.getY（））+”，
（int）数学圆（center.x*s），（int）数学圆（center.y*s）-d；
}
公共void绘图网格（Graphics2D g，int s）{
int w=getWidth（）；
inth=getHeight（）；
浮点dash1[]={2.0f}；
基本行程=
新基本行程（1.0f，
基本行程。盖头，
BasicStroke.JOIN_-MITER，
10.0f，dash1，0.0f）；
g、 设定行程（虚线）；
g、 setColor（颜色为灰色）；
int j=0；
虽然（这是最接近我需要的，尽管我正在结束问题并将其作为一个新主题发布，因为我认为人们并不完全理解我想要什么。如果你不能向stackoverflow解释，你就不能向你的计算机解释；-）祝你好运！