Java 二维旋转会留下洞

我正试图创建一个二维旋转没有任何运气，这里的代码

    public void render(int xPos, int yPos, double a, BitMap data){
    double angle = Math.toRadians(a);
    int xScr = 0;
    int yScr = 0;
    int CenterX = data.getWidth() / 2;
    int CenterY = data.getHeight() / 2;
    for(int y = 0; y < data.getHeight(); y++){
        yScr = (y + yPos);
        if(yScr < 0){
            continue;
        }
        else if(yScr >= height){
            return;
        }
        for(int x = 0; x < data.getWidth(); x++){
            xScr = (x + xPos);
            if(xScr < 0){
                continue;
            }
            if(yScr >= width){
                return;
            }
           int dataX = (int)(CenterX + (x - CenterX) * Math.cos(angle) - (y - CenterY) *Math.sin(angle));

           int dataY = (int)(CenterY + (x - CenterX) * Math.sin(angle) + (y - CenterY) * Math.cos(angle));

           if(dataX > 0 && dataX < data.getWidth()){
               if(dataY > 0 && dataY < data.getHeight()){
                    screenPixels.setValue(dataX, dataY, data.getValue(x, y));
               }
           }

        }
    }
}

---

立方体正在渲染和旋转，但它会留下洞。我知道这是因为dataX和dataY是四舍五入的，因为还有像素。我真的不知道从哪里开始，如果有人能编写缺少的代码，我会非常高兴，因为我这个周末要参加Ludumdar，但还没有弄明白这一点。请帮帮我

多亏了reddit.com/user/dd_123，下面的代码成功地旋转了位图

public void render2(int xPos, int yPos, double angle, BitMap data){
   double angle2 = Math.toRadians(angle);
   angle = angle2;
   int w = data.getWidth();
   int h  = data.getHeight();
   int size =  (int) (Math.sqrt(w * w + h * h));
   BitMap newBitMap = new BitMap(size, size);
   int xCenter = w / 2;
   int yCenter = h / 2;
   final int halfSize = size / 2;
   for(int y = 0; y < size; y++){
       for(int x = 0; x < size; x++){
          int samplePointX = x - halfSize;
          int samplePointY = y - halfSize;

          int xData, yData;
          xData = (int)(samplePointX * -Math.cos(angle) + samplePointY * Math.sin(angle));
          yData = (int)(samplePointX * -Math.sin(angle) - samplePointY * Math.cos(angle));
          xData += xCenter;
          yData += yCenter;
          if(!(xData >= 0 && xData < w)){
             continue;
          }
          if(!(yData >= 0 && yData < h)){
             continue;
          }
          if((x) + (y) * size > size * size){
             continue;
          }
          screenPixels.setValue(x, y, data.getValue(xData, yData));
       }
   }

}

位图类

public class BitMap {

public BitMap(int width, int height){
    this.width = width;
    this.height = height;

    this.data = new int[width * height];
}

public BitMap(int[] data, int width, int height) {
    this.data = data;
    this.width = width;
    this.height = height;
}

private int[] data;
private int width, height;

public int getWidth(){
    return width;
}

public int getHeight(){
    return height;
}

public int getValue(int x, int y){
    return data[x + y * width];
}

public BitMap fillWithValues(int value){
    for(int i = 0; i < data.length; i++){
        data[i] = value;
    }
    return this;
}

public void setValue(int xScr, int yScr, int value) {
    data[xScr + yScr * width] = value;
}

public int[] getValues() {
    return data;
}

public BitMap subData(int xPos, int yPos, int w, int h) {
    BitMap bitmap = new BitMap(w, h);
    for(int y = 0; y < h; y++){
        for(int x = 0; x < w; x++){
            bitmap.setValue(x, y, this.getValue(x + xPos, y + yPos));
        }
    }
    return bitmap;
}

---

}

我曾经解决过这个问题，先将图像放大4倍，然后旋转，然后再缩小。它很好地填补了漏洞，速度也不慢也不难。比特银行的答案也是好的。我没有想到要反向工作。

解决方法是从目标像素反向工作到源像素。这将确保全面覆盖。你能给我举个例子吗？因为我以前听过，但我不太明白我们是从那句话开始的。你在源图像中循环，把像素旋转到目标图像中。这将导致漏洞。相反，在目标图像中循环，并通过反向旋转找到源像素位置。我明天会尝试，但如果你有时间，请编写代码，这样我可以给你一个正确的答案。谢谢你的解释！所以我成功地做到了，但是现在旋转很奇怪。