Question

我是java的初学者。

我想自己做旋转，我知道如何使用Graphics类，但我试着理解它在这些类中是如何工作的。

我从谷歌图片中随机选择了一张图片。我把它变成了一个像素的数组，有了这个功能，效果很好：

map = objectMapper.readValue( json, HashMap.class );

然后，我根据给定的角度旋转了这个像素阵列。

BufferedImage immeuble = ImageIO.read( new File( "....jpg" ) );
int width = immeuble.getWidth();
int height = immeuble.getHeight();
int[] pixArray;
pixArray = Util.convertToPixels( immeuble );



public static int[] convertToPixels(Image img) {
            int width = img.getWidth(null);
            int height = img.getHeight(null);
            int[] pixel = new int[width * height];

        PixelGrabber pg = new PixelGrabber(img, 0, 0, width, height, pixel, 0, width);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
            throw new IllegalStateException("Error: Interrupted Waiting for Pixels");
        }
        if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
            throw new IllegalStateException("Error: Image Fetch Aborted");
        }
        return pixel;
    }

然后，我用旋转显示新图像，将数组（pixArray）转换为2d数组：

pixArray = util.rotate( angle, pixArray, width, height );

public int[] rotate( double angle, int[] pixels, int width, int height ) {
        final double radians = Math.toRadians( angle );
        final double cos = Math.cos( radians );
        final double sin = Math.sin( radians );
        final int[ ] pixels2 = new int[ pixels.length ];
        for( int pixel = 0; pixel < pixels2.length; pixel++ ) {
            pixels2[pixel] = 0xFFFFFF;
        }
        for( int x = 0; x < width; x++ ) {
            for( int y = 0; y < height; y++ ) {
                final int centerx = width / 2;
                final int centery = height / 2;
                final int m = x - centerx;
                final int n = y - centery;
                final int j = ( ( int ) ( m * cos + n * sin ) ) + centerx;
                final int k = ( ( int ) ( n * cos - m * sin ) ) + centery;
                if( j >= 0 && j < width && k >= 0 && k < height ){
                    pixels2[ ( y * width + x ) ] = pixels[ ( k * width + j ) ];
                }
            }
        }
        return pixels2;
    }

并创建一个新的BufferedImage：

array2d = util.monoToMulti( pixArray, height, width );
public int[][] monoToMulti(final int[] array, final int height, final int width) {
        if (array.length != (height * width))
            throw new IllegalArgumentException("Invalid array length");

        int[][] multi = new int[height][width];

        for ( int i = 0; i < height; i++ )
            System.arraycopy(array, (i*width), multi[i], 0, width);

        return multi;
    }

我有几个问题：

第一个是：我的图像，即使我没有制作旋转部分（util.rotate）。输出图像旋转90°C。我不知道为什么，我看不出问题出在哪里。
然后，如果我应用旋转部分，则剪切图像。因为我保持输入图像的宽度和高度，并且我想计算输出图像的范围，所以我可以在输出中获得完整的图像。我认为有一些正弦计算器，但我在三角学中并不擅长。

感谢您的帮助！

编辑：例如角度为18°

BufferedImage bufferedImage = new BufferedImage( array2d.length, array2d[0].length,
                                                         BufferedImage.TYPE_INT_ARGB );
        for ( int x = 0; x < array2d.length; x++ )
        {
            for ( int y = 0; y < array2d[x].length; y++ )
            {
                bufferedImage.setRGB( x, y, array2d[x][y] );
            }
        }


        util.saveToPNG( bufferedImage, "rotation_test" );

Answer 1

首先，我想说我同意ControlAltDel，你可能最好使用内置功能。</ p>

但是，我会尽力回答你的问题：

第一个是：我的图像，即使我没有制作旋转部分（util.rotate）。输出图像旋转90°C。我不知道为什么，我看不出问题出在哪里。

这可能来自您从2d像素阵列创建新图像的代码：

您的数组的第一个维度是高度，即每个元素是一个行的像素数组。但是当将像素设置为新数组时，您正在使用y和x，即迭代线并将线索引分配给x。那是你得到的交换错误。

示例：您正确应用了1D阵列布局，即它是第1行的所有像素，然后是第2行的所有像素，也在您的代码中显示：pixels2[ ( y * width + x ) ]

将该数组拆分为2D数组时，请按以下方式声明：

int[][] multi = new int[height][width];

正如您所看到的，第一个维度是height，但是，当再次循环遍历该数组时，您可以访问以下值：

bufferedImage.setRGB( x, y, array2d[x][y] );

所以你基本上把x坐标作为高度的索引，反之亦然，因此旋转90度（你基本上交换x和y）。

要解决此问题，只需将循环更改为先从y开始。

然后，如果我应用旋转部分，则剪切图像。因为我保持输入图像的宽度和高度，并且我想计算输出图像的范围，所以我可以在输出中获得完整的图像。我认为有一些正弦计算，但我在三角学中并不擅长。

您可以先计算角点的旋转位置（实际上只需要其中两个）并计算它们在x和y上与中心的距离，并使用最高值创建旋转图像的边界框

由于你在中心周围旋转，你只需要两个角，它们在x和y上的中心距离最大。最终尺寸将使这些距离加倍。

示例：

您只需要两个角，因此您可以使用第一行的第一个和最后一个像素。那些将具有坐标（x / y）0/0和宽度/ 0。

现在将它们提供给您的旋转代码（顺便说一下，计算环形外部矩形的中心）并获得旋转坐标，例如： x1/y1和x2/y2。

获取x和y上中心坐标的最大距离，即使用Math.max( Math.abs(x1-center_x), Math.abs(x2-center_x))等。

将最大距离加倍并获得新阵列的尺寸。

现在围绕其中心旋转原始图像，但在将它们放入新数组之前向坐标添加偏移量。偏移量将是两个阵列之间宽度和高度差异的一半。

像素阵列的旋转

1 个答案: