c ++ opencv viser billede på et vindue

Indlæg af Hanne Mølgaard Plasc

Problem



Jeg vil gerne indlæse et billede ved hjælp af OpenCV og derefter vise det på et vindue.


Jeg ved, hvordan man laver et billede ved hjælp af opencv og hvordan man opretter et vindue ved hjælp af win32, men hvordan går jeg med at sætte billedet/mat fra Opencv på vinduet bagefter?


Sådan laver jeg billedet fra opencv:


#include <opencv2/core/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <iostream>
#include <string>
using namespace cv;

using namespace std;

int main(int argc, char** argv)
{

    string imageName("C:/image.jpg"); // by default
    if (argc > 1)
    {
        imageName = argv[1];
    }

    Mat image;



    image = imread(imageName.c\_str(), IMREAD\_COLOR); 


    if (image.empty())     
    {
        cout << "Could not open or find the image" << std::endl;
        return -1;
    }


    namedWindow("Display window", WINDOW\_AUTOSIZE);

    imshow("Display window", image); 


    waitKey(0);
    return 0;
}


EDIT: Grunden til, at jeg vil gøre dette, er faktisk ikke at skabe et vindue i løbet af runtime og derefter vise billedet på det, men jeg vil gerne finde et vindue ved hjælp af win32s FindWindow-funktion og derefter tegne et billede på det: D

Bedste reference


Godt...


Du må ikke oprette et nyt vindue ved at kalde 'namedWindow ()'.


Ring derefter til imshow(nameOfExistingWindow, image).


Måske det vil fungere.

Andre referencer 1


Jeg bruger dette ganske ofte med mine MFC-projekter. Hvis du kun har hwnd, ikke CWnd, så skal du måske ændre lidt.


Dette virker både med 8-bit RGB farve og 1-kanals monokrom billede.


    void DrawImage( CWnd *wnd, int width, int height, int bpp, const unsigned char *buffer)
{
    RECT rect;
    wnd->GetWindowRect(&rect);
    CDC *dc = wnd->GetDC();

    if( bpp == 3) // BGR
    {
        BITMAPINFO bmpinfo;

        memset(&bmpinfo, 0, sizeof(bmpinfo));
        bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        bmpinfo.bmiHeader.biBitCount = 24;
        bmpinfo.bmiHeader.biClrImportant = 0;
        bmpinfo.bmiHeader.biClrUsed = 0;
        bmpinfo.bmiHeader.biCompression = BI\_RGB;
        bmpinfo.bmiHeader.biWidth = width;
        bmpinfo.bmiHeader.biHeight = -height;
        bmpinfo.bmiHeader.biPlanes = 1;
        bmpinfo.bmiHeader.biSizeImage = 0;
        bmpinfo.bmiHeader.biXPelsPerMeter = 100;
        bmpinfo.bmiHeader.biYPelsPerMeter = 100;

        ::SetStretchBltMode( dc->GetSafeHdc(), COLORONCOLOR);
        ::StretchDIBits(    dc->GetSafeHdc(),
                        0,
                        0,
                        rect.right - rect.left, 
                        rect.bottom - rect.top,
                        0,
                        0,
                        width,
                        height,
                        buffer,
                        &bmpinfo,
                        DIB\_RGB\_COLORS,
                        SRCCOPY);
    }
    else if ( bpp == 1) // monochrome.
    {
        char bitmapInfoBuf[sizeof(BITMAPINFO) + 4 * 256];
        BITMAPINFO* pBmpInfo = (BITMAPINFO*)bitmapInfoBuf;

        memset(pBmpInfo, 0, sizeof(BITMAPINFO) + 4 * 256);
        pBmpInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        pBmpInfo->bmiHeader.biWidth = width;
        pBmpInfo->bmiHeader.biHeight = -height;
        pBmpInfo->bmiHeader.biCompression = BI\_RGB;
        pBmpInfo->bmiHeader.biPlanes = 1;
        pBmpInfo->bmiHeader.biBitCount = 8;

        for(int i = 0; i < 256; i++)
        {
            pBmpInfo->bmiColors[i].rgbBlue=i;
            pBmpInfo->bmiColors[i].rgbGreen=i;
            pBmpInfo->bmiColors[i].rgbRed=i;
            pBmpInfo->bmiColors[i].rgbReserved=255;
        }

        ::SetStretchBltMode( dc->GetSafeHdc(), COLORONCOLOR);
        ::StretchDIBits( dc->GetSafeHdc(),
                        0, 
                        0, 
                        rect.right - rect.left, 
                        rect.bottom - rect.top, 
                        0, 
                        0, 
                        width, 
                        height, 
                        buffer, 
                        pBmpInfo, 
                        DIB\_RGB\_COLORS, 
                        SRCCOPY);
    }

    wnd->ReleaseDC(dc);
}

void DrawCVImage(cv::Mat image, CWnd *picture)
{
    if (image.cols \% 4 == 0)
    {
        DrawImage(picture, 
            image.cols, 
            image.rows,
            image.channels() == 3 ? 3 : 1,
            image.data);
    }
    else
    {
        Mat image2(image.rows, image.cols + ( 4 - image.cols \% 4), image.type());
        image2 = 0;
        image.copyTo(image2(Rect(0, 0, image.cols, image.rows)));

        DrawImage(picture, 
            image2.cols, 
            image2.rows,
            image2.channels() == 3 ? 3 : 1,
            image2.data);
    }
}