How to fix resized image in MFC?

edit

• MFC requires DWORD memory alignment for bitmaps rows
• When you prepare an image for MFC the matrix elements needs to be stored continuously without gaps at the end of each row.

Than cv::Mat mat must be:

1. Continuous (no ROI nor sparse). Mat::isContinuous() checks the case.
2. Byte based pixel type (RGB, RGBA,GRAY). you could use cv::cvtColor
3. and (bpp * mat.cols) % 4 == 0. You could use cv::copyMakeBorder or cv::cvtColor

If the image is not continuous (eg is a ROI) you should use in-place operation with care because it would be not continuous again.

About memory alignment, looking at How the image matrix is stored in the memory? you can see that for a cv::Mat BytesForRows = bpp * mat.cols where bpp is number of byte for each pixel.

• For 32bit RGBA/GBRA images all is fine because 1pix=4bytes than rows are always DWORD aligned.
• For GRAY images, 1pix=1byte than you will have DWORD alignment on rows only if cols%4==0
• For RGB/BGR images, 1pix=3byte than you need (3*cols)%4==0 bytes. You could add needed bytes at the end of each cv::Mat rows but this is a bit hard in OpenCV so is easier to add needed pixel instead of needed bytes.

Definitely you should have 32bit image or image cols as multiple of 4: cols % 4 == 0. This is fine for GRAY and RGB images because 4 x cols x bpp is always a multiple of 4 than DWORD aligned on rows.

here the code:

Mat mat;
mat=imread("aaa.bmp");

if ( mat.type() == CV_8UC1 ) {
    cout << "not working because a greyscale palette is needed or you could use cv::cvtColor";
    return;
}
else if ((mat.type() != CV_8UC3) && (mat.type() != CV_8UC4)) {
    cout << "image type not supported or you could use cv::cvtColor";
    return;
}

//really you could avoid this because is done by MFC StretchDIBits
//resize(mat,mat,cv::Size(rc.Width(),rc.Height()));
int x=mat.cols;
int y=mat.rows;

int padding = 0;
if (mat.type() != CV_8UC4) // padding is not needed for 32bit images
{
    padding = 4 - (x % 4);
    if(padding==4)
        padding = 0;
}

cv::Mat matTmp;
if (padding > 0 || mat.isContinuous() == false)
{
  // Adding needed columns on the right (max 3 px)
  cv::copyMakeBorder(mat, matTmp, 0, 0, 0, padding, cv::BORDER_CONSTANT, 0);
}
else
{
  matTmp = mat;
}

Now you have right memory shape for a MFC bitmap. You can draw it avoiding the border using:

//real cols in the bitmap header
pheader->biWidth    = matTmp.cols;

//wanted cols (original cols) for drawing
StretchDIBits( dc.GetSafeHdc()
            ,0, 0, rc.Width(), rc.Height()
            ,0, 0, x, y,
            matTmp.data, &bmi, DIB_RGB_COLORS, SRCCOPY);

Finally your code will not work in case the image is grey scale because you need to prepare right palette in BITMAPINFOHEADER

As alternative, instead of cv::copyMakeBorder you could use cv::cvtColor(mat,xxx2BGRA) . This is slower (because of math operations) and memory consuming (because of needed channels) but will works for all input format. Example: given a BGR image 3 ... (more)