Bilinear interpolation in 2D transformation Qt

I'm currently working on 2D transformations (translation, scaling, shearing and rotation) in Qt. I have a problem with bilinear interpolation, which I want to use to cover the 'black pixels' in output image. I'm using matrix calculations to get new coordinates of pixels of input image. Then I use reverse matrix calculation to check which pixel of input image responds to output pixel. Result of that is some float number which I use to interpolation. I check the four neighbour points and calculate the value (color) of output pixel. I have checked my calculations 'by hand' and they seem to be good.

Can anyone find any bug in that code? (I cut out the parts of code which are responsible for interface such as sliders).

Here is what i get: http://imgur.com/a/vSYkF

Code:

---

Geometric::Geometric(QWidget* parent) : QWidget(parent) {
    resize(1000, 800);
    displayLogoDefault = true;
 
    a = shx = shy = x0 = y0 = 0;
    scx = scy = 1;
    tx = ty = 0;
    x = 200, y = 200;
    paintT = paintSc = paintR = paintShx = paintShy = false;
 
    img = new QImage(600,600,QImage::Format_RGB32);
    img2 = new QImage("logo.jpeg");
}
Geometric::~Geometric() {
    delete img;
    delete img2;
    img = NULL;
    img2 = NULL;
}
 
void Geometric::makeChange() {
    displayLogoDefault = false;
 
    // iteration through whole input image
    for(int i = 0; i < img2->width(); i++) {
        for(int j = 0; j < img2->height(); j++) {
 
            // calculate new coordinates basing on given 2D transformations values 
            //I calculated that formula eariler by multiplying/adding matrixes
            x = cos(a)*scx*(i-x0) - sin(a)*scy*(j-y0) + shx*sin(a)*scx*(i-x0) + shx*cos(a)*scy*(j-y0);
            y = shy*(x) + sin(a)*scx*(i-x0) + cos(a)*scy*(j-y0);
 
            // tx and ty goes for translation. scx and scy for scaling
            // shx and shy for shearing and a is angle for rotation
 
            x += (x0 + tx);
            y += (y0 + ty);
 
            if(x >= 0 && y >= 0 && x < img->width() && y < img->height()) {
                // reverse matrix calculation formula to find proper pixel from input image
                float tmx = x - x0 - tx;
                float tmy = y - y0 - ty;
                float recX = 1/scx * ( cos(-a)*( (tmx + shx*shy*tmx - shx*tmx) ) + sin(-a)*( shy*tmx - tmy ) ) + x0 ;
                float recY = 1/scy * ( sin(-a)*(tmx + shx*shy*tmx - shx*tmx) - cos(-a)*(shy*tmx-tmy) ) + y0;
 
 
                // here the interpolation starts. I calculate the color basing on four points from input image
                // that points are taken from the reverse matrix calculation
                float a = recX - floorf(recX);
                float b = recY - floorf (recY);
 
                if(recX + 1 > img2->width()) recX -= 1;
                if(recY + 1 > img2->height()) recY -= 1;
 
                QColor c1 = QColor(img2->pixel(recX, recY));
                QColor c2 = QColor(img2->pixel(recX + 1, recY));
                QColor c3 = QColor(img2->pixel(recX , recY + 1));
                QColor c4 = QColor(img2->pixel(recX + 1, recY + 1));
 
                float colR = b * ((1.0 - a) * (float)c3.red() + a * (float)c4.red()) + (1.0 - b) * ((1.0 - a) * (float)c1.red() + a * (float)c2.red());
                float colG = b * ((1.0 - a) * (float)c3.green() + a * (float)c4.green()) + (1.0 - b) * ((1.0 - a) * (float)c1.green() + a * (float)c2.green());
                float colB = b * ((1.0 - a) * (float)c3.blue() + a * (float)c4.blue()) + (1.0 - b) * ((1.0 - a) * (float)c1.blue() + a * (float)c2.blue());            
                if(colR > 255) colR = 255; if(colG > 255) colG = 255; if(colB > 255) colB = 255;
                if(colR < 0 ) colR = 0; if(colG < 0 ) colG = 0; if(colB < 0 ) colB = 0;
                paintPixel(x, y, colR, colG, colB);
            }
        }
    }
    // x0 and y0 are the starting point of image
    x0 = abs(x-tx);
    y0 = abs(y-ty);
    repaint();
}
 
// function painting a pixel. It works directly on memory
void Geometric::paintPixel(int i, int j, int r, int g, int b) {
    unsigned char *ptr = img->bits();
    ptr[4 * (img->width() * j + i)] = b;
    ptr[4 * (img->width() * j + i) + 1] = g;
    ptr[4 * (img->width() * j + i) + 2] = r;
 
}
 
void Geometric::paintEvent(QPaintEvent*) {
    QPainter p(this);
    p.drawImage(0, 0, *img);
    if (displayLogoDefault == true) p.drawImage(0, 0, *img2);
}

---

Do you mean that the problem are the dark artifacts?
I am just guessing here, but since your calculation produces floats, while the pixel positions are discrete, it could be that you are seeing a rounding artifact.
But as I said, this is just a guess.

Thank you for your answer. Those calculations should return a float because the part after the coma is used to calculate to which pixel of input image responds to the pixel of output image closer so I can select its colour.

Quote:

---

Those calculations should return a float

---

I did not question that, I just said that it *could be* that this leads to a rounding error which may move result in an "uneven" pixel distribution.