标签: affinetransform

使用AffineTransform类在Java中旋转图像时遇到一些问题.

我有以下方法来创建图像的旋转(90度)副本:

private BufferedImage createRotatedCopy(BufferedImage img, Rotation rotation) {
    int w = img.getWidth();
    int h = img.getHeight();

    BufferedImage rot = new BufferedImage(h, w, BufferedImage.TYPE_INT_RGB);

    double theta;
    switch (rotation) {
        case CLOCKWISE:
            theta = Math.PI / 2;
            break;
        case COUNTERCLOCKWISE:
            theta = -Math.PI / 2;
            break;
        default:
            throw new AssertionError();
    }

    AffineTransform xform = AffineTransform.getRotateInstance(theta, w / 2, h / 2);
    Graphics2D g = (Graphics2D) rot.createGraphics();
    g.drawImage(img, xform, null);
    g.dispose();

    return rot;
}

旋转是一个简单的枚举,值为NONE,CLOCKWISE和COUNTERCLOCKWISE.

我的问题的症状显示在这里:

http://perp.se/so/rotate_problems.html

因此,旋转工作正常,但生成的图像不会锚定到正确的坐标(或应该如何放置).因为我真的不知道我在做什么(我的线性代数很弱),我不知道如何自己解决这个问题.

我尝试了一些随机摆弄AffineTransform实例,但它没有帮助我(当然).我试过谷歌搜索(并搜索SO),但我见过的所有例子基本上都使用与我相同的方法...这对我不起作用.

感谢您的建议.

我对16位数据使用双线性插值有问题.我有两个图像,origImage和displayImage.我想使用AffineTransformOp通过AffineTransform将origImage过滤到displayImage,这是显示区域的大小.origImage的类型为BufferedImage.TYPE_USHORT_GRAY,并且具有sun.awt.image.ShortInterleavedRaster类型的栅格.这是我现在的代码

displayImage = new BufferedImage(getWidth(), getHeight(), origImage.getType());
try {
    op = new AffineTransformOp(atx, AffineTransformOp.TYPE_BILINEAR);
    op.filter(origImage, displayImage);
}
catch (Exception e) {
    e.printStackTrace();
}

为了显示错误,我创建了2个渐变图像.一个具有15位范围内的值(最大值为32767),另一个值位于16位范围内(最大值为65535).以下是两张图片

15位图像

16位图像

这两个图像是以相同的方式创建的,看起来应该相同,但请注意16位图像中间的线条.起初我认为这是一个溢出问题,然而,奇怪的是它在梯度的中心而不是在像素值更高的末端表现出来.此外,如果它是溢出问题,我怀疑15位图像也会受到影响.

任何有关这方面的帮助将不胜感激.

我只是想知道为什么没有人回答,我提供了足够的信息吗？需要更多信息吗？

下面是我用来生成AffineTransform的代码.所有引用的变量都是根据用户输入(鼠标移动)计算出来的,并且应该是正确的(它已被包括我自己在内的很多人测试过).希望这可以帮助解决错误.

AffineTransform panTranslate = new AffineTransform();
panTranslate.translate(imagePanOffset.x, imagePanOffset.y);

AffineTransform rotateCenterTranslate = new AffineTransform();
rotateCenterTranslate.translate(imageRotateCTR.x, imageRotateCTR.y);
AffineTransform rotateTransform = new AffineTransform();
rotateTransform.rotate(Math.toRadians(rotateValue));
AffineTransform rotateAntiCenterTranslate = new AffineTransform();
rotateAntiCenterTranslate.translate(-imageRotateCTR.x, -imageRotateCTR.y);

AffineTransform translateTransform = new AffineTransform();
translateTransform.translate(imageMagOffset.x, imageMagOffset.y);

AffineTransform flipMatrixTransform = new AffineTransform();

switch (flipState) {
    case ENV.FLIP_NORMAL: // NORMAL
        break;

    case ENV.FLIP_TOP_BOTTOM: // …

我之前从未使用过Java绘图方法,所以我决定潜入并创建一个模拟时钟作为PoC.除了手之外,我画了一个钟面,包括刻度标记,分钟/小时.我使用简单的sin/cos计算来确定圆周线的位置.

但是,我注意到由于分钟刻度非常短,因此线条的角度看起来不对.我确定这是因为两者Graphics2D.drawLine()和Line2D.double()方法都无法以亚像素精度绘制.

我知道我可以画出来自中心的线条并用圆圈遮住它(以创建更长,更准确的线条),但这似乎是一种不那么优雅和昂贵的解决方案.我已经做过一些关于如何做到这一点的研究,但我遇到的最好的答案是使用一个AffineTransform.我假设我只能使用AffineTransformwith旋转,而不是必须执行超级采样.

这是以亚像素精度绘制的唯一/最佳方法吗？或者是否有更快的解决方案？

编辑:我已经设置RenderingHint的Graphics2D对象.

根据要求,这里有一些代码(没有完全优化,因为这只是一个PoC):

diameter = Math.max(Math.min(pnlOuter.getSize().getWidth(),
                             pnlOuter.getSize().getHeight()) - 2, MIN_DIAMETER);

for (double radTick = 0d; radTick < 360d; radTick += 6d) {
   g2d.draw(new Line2D.Double(
      (diameter / 2) + (Math.cos(Math.toRadians(radTick))) * diameter / 2.1d,
      (diameter / 2) + (Math.sin(Math.toRadians(radTick))) * diameter / 2.1d,
      (diameter / 2) + (Math.cos(Math.toRadians(radTick))) * diameter / 2.05d,
      (diameter / 2) + (Math.sin(Math.toRadians(radTick))) * diameter / 2.05d));
} // End for(radTick) …

我有一个我正在考虑旋转的MKMapView,以便更方便地向我的用户显示一系列注释.

到目前为止,我计划用CGAffineTransform简单地旋转整个视图,但我想知道是否有人有任何MKMapView旋转经验.

• 添加旋转时是否存在任何陷阱或"陷阱"？
• 是否有更简单的方法来旋转mapview？
• 如果我有一个叠加,convertCoordinate:toPointToView:方法仍然以相同的方式工作？我会假设我必须将相同的变换应用于我的叠加层以便排列点,但也许方法比这更聪明.

如果您认为有什么可以帮助我,我很乐意听到这一切.

编辑:经过多次实验,我相信我将使用静态地图,我可以自己旋转和叠加,但是,我仍然会对MKMapView旋转的任何信息感兴趣.

我正在寻找旋转图像.我有一个JInternalFrame包含一个JLabel.标签包含图像.旋转图像后,我需要调整内部框架的大小.我目前的代码旋转图像,但图像边缘周围有黑色,并且偏离中心.对于如何解决这个问题,有任何的建议吗？

public void rotateIcon(int angle)
{
        int w = theLabel.getIcon().getIconWidth();
        int h = theLabel.getIcon().getIconHeight();
        int type = BufferedImage.TYPE_INT_RGB;  // other options, see api

        BufferedImage DaImage = new BufferedImage(h, w, type);
        Graphics2D g2 = DaImage.createGraphics();

        double x = (h - w)/2.0;
        double y = (w - h)/2.0;
        AffineTransform at = AffineTransform.getTranslateInstance(x, y);

        at.rotate(Math.toRadians(angle), w/2.0, h/2.0);
        g2.drawImage(new ImageIcon(getData()).getImage(), at, theLabel);
        g2.dispose();

        theLabel.setIcon(new ImageIcon(DaImage));
        this.setSize(DaImage.getWidth(),DaImage.getHeight()); //resize the frame
}

创建AffineTransform哪个地图坐标从一个矩形到另一个矩形(给出浮点/双矩形)的最简单方法是什么？

更新1

矩形可以完全不同.例如[(0,0) - (1,1)]和[(150,-14) - ( - 1000,-14.1)].转型应该统一转变.例如,矩形角应该一对一转换.例如,坐标(0,0)应转向(150,-14).

更新2

我需要AffineTransform对象,而不仅仅是计算.因为我想将它应用于Graphics对象.此外,我想以简单变换的一些连接的形式.

更新3

以下3项测试都失败了:

public class RectangleTransformTest {

    private static final double delta = 0.001;

    Rectangle2D r1 = new Rectangle2D.Double(-1, 0, 2, 0.01);
    Rectangle2D r2 = new Rectangle2D.Double(10, 20, 400, 300);

    AffineTransform t;

    Point2D src;
    Point2D dst1, dst2;

    @Test
    public void test1() {

        t = new AffineTransform();
        t.translate(+r2.getMinX()-r1.getMinX(), +r2.getMinY()-r1.getMinY());
        t.scale(r2.getWidth()/r1.getWidth(), r2.getHeight()/r1.getHeight());

    }

    @Test
    public void test2() {

        t = new AffineTransform();

        t.scale(r2.getWidth()/r1.getWidth(), r2.getHeight()/r1.getHeight());
        t.translate(+r2.getMinX()-r1.getMinX(), +r2.getMinY()-r1.getMinY()); …

我见过几个类似的问题，并对我可能尝试的内容有一些想法，但我不记得看到过任何有关传播的内容。

所以：我正在开发一个测量系统，最终基于计算机视觉。

我进行 N 个捕获，并使用一个库来处理它们，该库以平移和旋转的 4x4 仿射变换矩阵的形式输出姿势估计。

这些姿势估计中有一些噪音。每个旋转轴的欧拉角的标准偏差小于 2.5 度，因此所有方向都非常接近（对于所有欧拉角都接近 0 或 180 的情况）。小于 0.25 度的标准误差对我来说很重要。但我已经遇到了欧拉角特有的问题。

我想对所有这些非常接近的姿势估计进行平均以获得单个最终姿势估计。我还想找到一些传播的衡量标准，以便我可以估计准确性。

我知道“平均”对于轮换实际上并没有很好的定义。

（郑重声明，我的代码是使用 Numpy 的 Python 编写的。）

我也可能想对这个平均值进行加权，因为已知某些捕获（和某些轴）比其他捕获更准确。

我的印象是，我可以只取平移向量的平均值和标准差，对于旋转，我可以转换为四元数，取平均值，并以良好的精度重新归一化，因为这些四元数非常接近。

我还听说过所有四元数中的最小二乘法，但我对如何实现这一点的大部分研究都以惨败告终。

这可行吗？在这种情况下是否有一个合理明确的传播衡量标准？

我有两个PIL图像和两组相应的2D点,它们构成一个三角形.

例如:

image1:
100x100 pixels
points = [(10,10), (20,20), (10,20)]

image2:
250x250 pixels
points = [(35,30), (75,19), (50,90)]

我想从image1复制三角形区域并将其转换为适合image2的相应三角形区域.有没有办法用PIL做这个而不必逐个像素地复制并自己计算转换？

这最近几天一直在杀我.甚至没有开玩笑,但我一直在努力解决这个问题.

我目前正在尝试使用仿射变换矩阵在HTML5中创建等轴投影.我收到的瓷砖是一个旋转45度的正方形(基本上是方形帆布上的方形钻石).然后,我根据x或y方向是否存在增量来缩放其中一个轴.然后我将轴倾斜一个因子来拟合.然后,我通过向后旋转-45度来否定初始旋转.

目前,我的仿射矩阵是:

      // note: the difference in z is about 10 in this example,
      //       so, xDiff is usually 40
      var xDiff  = 4 * (center.z   - map[x+1][y].land.z);
      var yDiff  = 4 * (center.z   - map[x][y+1].land.z);

      var matrix = multiplyAll(
        // Rotation
        [COS45,  SIN45,
         -SIN45, COS45],

        // Scale in each respective axis
        [(44+yDiff)/44, 0,
         0, (44+xDiff)/44],

        // Skew each axis
        [1,  -yDiff/(44+yDiff),
         -xDiff/(44+xDiff), 1],

        // Negate the rotation
        [NCOS45, NSIN45,
        -NSIN45, NCOS45]
      );

然后我用它绘制它:

      // the map has its …

我上课了Airplane.在这个类里面我有变量img这是一个BufferedImage类型.更有甚至,我有WorldMap一个覆盖功能的类paintComponent(Graphics g):

@Override
public void paintComponent(Graphics g) {
    Graphics2D g2d = (Graphics2D) g;
    g2d.drawImage(mapa, 0, 0, getWidth(), getHeight(), null); 
    drawAirplanes(g2d);
}

功能drawAirplanes()如下:

private void drawAirplane(Graphics2D g){
    for(Samolot i: s){
        i.rotateAirplane();
        g.drawImage(i.getImg(),i.getX(),i.getY(),(int)i.getDim().getWidth(),(int)i.getDim().getHeight(),  null);
    }
}

它只需要1)旋转飞机(飞机物体内的BufferedImage)2)画他.

我的Airplane.rotateAirplane()函数如下所示:

 public void rotateSamolot() {
   AffineTransform tx = new AffineTransform();

   tx.translate(10,10); //10, 10 is height and width of img divide by 2
   tx.rotate(Math.PI / 2);
   tx.translate(-10,-10); 

   AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);

   BufferedImage …