2D rotation is leaving holes

Question

i'm trying to create a 2d rotation without any luck, here's the code!

    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));
               }
           }

        }
    }
}

The cube is rendering and is rotating, but it's leaving holes. I know it's because dataX and dataY is rounding of and there for there will be pixels left. I don't really know where to get started, and I would be really happy if someone could code write the code that's is missing, because i'm going to participate in Ludumdare this weekend and haven't still figured out this. Please, help me!

Answer 1

The following code successfully rotates a bitmap, thanks to 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));
       }
   }

}

The bitmap class

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;
}

}

Answer 2

I solved this problem once by scaling the image up first 4X, rotating, than scaling back down. It filled the holes quite nicely and wasn't to slow or difficult. BitBank's answer is good also. Working it backwards hadn't occurred to me.