Java初学者坐标出界

Question

我一直在学习如何旋转图片，我必须将图片旋转180度和270度。我还没有开始270，我似乎不知道如何修复越界错误

public Picture rotate180()
{
    Picture rotated = new Picture ();

    for (int x = 0, roty = 0; x < getWidth(); x++, roty++)
    {
      for (int y = 0, rotx = getWidth()-1; y<getHeight(); y++, rotx--)
      {
        Pixel oldPixel = getPixel(x,y);
        Pixel newPixel = getPixel(rotx,roty);
        newPixel.setColor(oldPixel.getColor());
      }
    }
return rotated;
}

Answer 1

如上所述，for循环对图片旋转没有任何作用。我假设你的“getWidth（）”调用应该得到“rotated”的宽度。如果是这样的话，那么你需要把它旋转。getWidth（）来访问该属性。在剩下的代码中也使用同样的方法rotated.getHeight(); rotated.getPixel (x, y) 等 另外，在for循环中使用两个int值作为增量，它们总是相等的，可以只使用一个

Answer 2

private enum Degree {
    _90_ {
        public Picture rotate(Picture picture) {
            Picture res = swapRowCol(new Picture(picture.height, picture.width), picture);

            // mirror each column
            for (int col = 0; col < res.width; col++)
                for (int row1 = 0, row2 = res.height - 1; row1 < row2; row1++, row2 )
                    swapColor(res, col, row1, col, row2);

            return res;
        }
    },
    _180_ {
        public Picture rotate(Picture picture) {
            Picture res = new Picture(picture.width, picture.height);

            // desc rows and mirror each one
            for (int row1 = 0, row2 = res.height - 1; row1 < res.height; row1++, row2 )
                for (int col1 = 0, col2 = picture.width - 1; col1 < picture.width; col1++, col2 )
                    res.getPixel(col2, row2).setColor(picture.getPixel(col1, row1).getColor());

            return res;
        }
    },
    _270_ {
        public Picture rotate(Picture picture) {
            Picture res = swapRowCol(new Picture(picture.height, picture.width), picture);

            // mirror each row
            for (int row = 0; row < res.height; row++)
                for (int col1 = 0, col2 = res.width - 1; col1 < col2; col1++, col2 )
                    swapColor(res, col1, row, col2, row);

            return res;
        }
    };

    public abstract Picture rotate(Picture picture);

    protected static Picture swapRowCol(Picture dst, Picture src) {
        // (x;y) -> (y;x)
        for (int row = 0; row < src.height; row++)
            for (int col = 0; col < src.width; col++)
                dst.getPixel(row, col).setColor(src.getPixel(col, row).getColor());

        return dst;
    }

    protected static void swapColor(Picture res, int srcCol, int srcRow, int dstCol, int dstRow) {
        Pixel pixel1 = res.getPixel(srcCol, srcRow);
        Pixel pixel2 = res.getPixel(dstCol, dstRow);
        int color = pixel1.getColor();
        pixel1.setColor(pixel2.getColor());
        pixel2.setColor(color);
    }
}

Answer 3

在更一般的情况下，要旋转到任何角度，必须使用javax。imageio*

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;

public final class ImageUtils {
    public static BufferedImage rotateImage(BufferedImage image, int degreeAngle) {
        degreeAngle = normalizeAngle(degreeAngle);

        if (degreeAngle == 0 || image == null)
            return image;

        double theta = Math.toRadians(degreeAngle);
        double cosTheta = Math.abs(Math.cos(theta));
        double sinTheta = Math.abs(Math.sin(theta));
        int width = (int)Math.rint(image.getWidth() * cosTheta + image.getHeight() * sinTheta);
        int height = (int)Math.rint(image.getWidth() * sinTheta + image.getHeight() * cosTheta);
        Graphics2D graphics = null;

        try {
            AffineTransform at = new AffineTransform();
            BufferedImage rotatedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            graphics = rotatedImage.createGraphics();

            at.rotate(theta, image.getWidth() / 2, image.getHeight() / 2);
            at.preConcatenate(balanceImagePosition(at, image));

            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            graphics.drawRenderedImage(image, at);

            return rotatedImage;
        } finally {
            if (graphics != null)
                graphics.dispose();
        }
    }

    /**
     * Transform given angle in degree of any range to the [0;360) range
     *
     * @param degreeAngle angle in degree
     * @return normalized angle in degree
     */
    private static int normalizeAngle(int degreeAngle) {
        if (degreeAngle <= -360 || degreeAngle >= 360)
            degreeAngle %= 360;
        if (degreeAngle < 0)
            degreeAngle += 360;

        return degreeAngle;
    }

    private static AffineTransform balanceImagePosition(AffineTransform at, BufferedImage image) {
        Point2D[] points = { new Point2D.Double(0, 0), new Point2D.Double(image.getWidth(), 0), new Point2D.Double(0,
                image.getHeight()), new Point2D.Double(image.getWidth(), image.getHeight()) };
        double tx = image.getWidth();
        double ty = image.getHeight();

        for (Point2D point : points) {
            Point2D tmp = at.transform(point, null);
            tx = Math.min(tx, tmp.getX());
            ty = Math.min(ty, tmp.getY());
        }

        at = new AffineTransform();
        at.translate(-tx, -ty);

        return at;
    }
}