Draw Functions

NOTE: Draw functions and LDisplay Control is now only implemented on Windows. For others (Mac / Linux), the functions and related interfaces are retained but non-functional.

For the image and the drawable LPV classes which implements the ILDrawable interface, we usually provide the Draw functions to paint the class's content on the provided device context, aka. the HDC handle.

It is a more flexible and light-weighted API for the users to fully control the graphics rendering of their applications, compared with the LDisplay Control.

Here are some example draw functions for the image, region and detection results:

void ILImage::Draw (HDC hdc, double zoomX, double zoomY, double panX, double panY); 
 
void ILRegion::Draw (HDC hdc, BOOL bHandles, double zoomX, double zoomY, double panX, double panY);
 
void ILMatchResults::Draw (HDC hdc, int index, LPVPatDrawFlags drawFlags, double zoomX, double zoomY, double panX, double panY)
void ILMatchResults::DrawAll (HDC hdc, LPVPatDrawFlags drawFlags, double zoomX, double zoomY, double panX, double panY)

They have the common parameters for specifying the drawing device context and controlling the view port.

Parameters

[in]	hdc	Handle to the device context of the destination window or bitmap.
[in]	zoomX	Factor for zooming in or out in the x-coordinate direction. By default, it's 1, means the true 100% scale.
[in]	zoomY	Factor for zooming in or out in the y-coordinate direction. Set to 0 means same zoom factor as zoomX, aka. isotropic scaling.
[in]	panX	translation in the x-coordinate direction for panning. The final display x position is calculated as: \( (x + panX) \times zoomX \)
[in]	panY	translation in the y-coordinate direction for panning. The final display y position is calculated as: \( (y + panY) \times zoomY \)

They may also have the extra parameters to control drawing behavior.

Examples for Use the Draw Functions

Draw on the Bitmap

C++

void DrawImageAndResultsOnStatic(QLabel* picItem, ILImagePtr img, ILRectRegionPtr roi, ILMatchResultsPtr matchResults)
{
    // adapt to size of ui widget
    QRect pictureRect = picItem->geometry();
    double zoomx = (double)pictureRect.width() / w;
    double zoomy = (double)pictureRect.height() / h;
    
    // create the new memory DC and bitmap for painting
    HDC dc = GetDC(NULL);
    HDC hdc = CreateCompatibleDC(dc);
    HBITMAP hbmp = CreateCompatibleBitmap(dc, pictureRect.width(), pictureRect.height());
    SelectObject(hdc, hbmp);
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    img->Draw(hdc, zoomx, zoomy, 0, 0);
    roi->Draw(hdc, true, zoomx, zoomy, 0, 0);
    matchResults->DrawAll(hdc, LPVPatDrawDefault, zoomx, zoomy, 0, 0);
    
    // set Bitmap to QLabel
    picItem->setPixmap(QtWin::fromHBITMAP(hbmp));
    
    // release the memory hdc and bitmap
    ReleaseDC(NULL, dc);
    DeleteObject(hdc);
    DeleteObject(hbmp);
}

C#

void drawImageAndResultsOnStatic(PictureBox picItem, LImage img, LRectRegion roi, LMatchResults match_results)
{
    // adapt to size of ui widget
    double zoomX = (double)picItem.Width / img.Width;
    double zoomY = (double)picItem.Height / img.Height;
    
    // create the new memory DC and bitmap for painting
    Bitmap bmp = new Bitmap(picItem.Width, picItem.Height);
    Graphics gfx = Graphics.FromImage(bmp);
    gfx.Clear(Color.White); // white background
    IntPtr hdc = gfx.GetHdc(); // get hdc for drawing
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    img.Draw(hdc, zoomX, zoomY);
    roi.Draw(hdc, true, zoomX, zoomY);
    match_results.DrawAll(hdc, LPVPatDrawFlags.LPVPatDrawDefault, zoomX, zoomY);
    
    gfx.ReleaseHdc(hdc);
    gfx.Dispose();
    
    // display bitmap in picture control
    if (picItem.Image != null)
        picItem.Image.Dispose();
    picItem.Image = bmp;
}

COM

void DrawImageAndResultsOnStatic(CStatic* picItem, ILImagePtr img, ILRectRegionPtr roi, ILMatchResultsPtr matchResults)
{
    // you should firstly modify the static control's style to accept bitmap
    // you should do it in the dialog's initialization method OnInitDialog(), like:
    // ((CStatic*)GetDlgItem(IDC_IMG_PIC))->ModifyStyle(0xF, SS_BITMAP, SWP_NOSIZE);
    
    CRect picRect;
    picItem->GetClientRect(picRect);
    
    // adapt to size of ui widget
    double zoomx = (double)picRect.Width() / img->Width;
    double zoomy = (double)picRect.Height() / img->Height;
    
    CDC* picdc = picItem->GetDC();
    if (!picdc) return;
    
    // create the new memory DC and bitmap for painting
    HDC pichdc = picdc->GetSafeHdc();
    HDC hdc = CreateCompatibleDC(pichdc);
    HBITMAP bitmap = CreateCompatibleBitmap(pichdc, picRect.Width(), picRect.Height());
    
    // replace with new created bitmap
    HBITMAP prevBitmap = (HBITMAP)SelectObject(hdc, bitmap);
    if (prevBitmap) DeleteObject(prevBitmap);
    
    // white background
    FillRect(hdc, &picRect, (HBRUSH)GetStockObject(WHITE_BRUSH));
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    img->Draw(hdc, zoomx, zoomy, 0, 0);
    roi->Draw(hdc, VARIANT_TRUE, zoomx, zoomy, 0, 0);
    matchResults->DrawAll(hdc, LPVPatDrawDefault, zoomx, zoomy, 0, 0);
    
    // refresh the ui
    BitBlt(pichdc, picRect.left, picRect.top, picRect.Width(), picRect.Height(), hdc, 0, 0, SRCCOPY);
    picItem->ReleaseDC(picdc);
    
    // release the memory hdc and bitmap
    DeleteObject(hdc);
    DeleteObject(bitmap);
}

Draw in the OnPaint Method

C++

QtDlg::QtDlg(QWidget* parent = nullptr) : QDialog(parent)
{
    // set Qt::WA_PaintOnScreen attribute
    QtDlg->setAttribute(Qt::WA_PaintOnScreen, true);
}
 
QPaintEngine* QtDlg::paintEngine() const
{
    // per document of Qt::WA_PaintOnScreen, re-implement QWidget::paintEngine() to return 0
    return nullptr;
}
 
void QtDlg::paintEvent(QPaintEvent* event)
{
    // get native DC for painting
    HDC hdc = this->getDC();
    QSize picSize = this->size();
    
    // adapt to size of ui widget
    double zoomx = (double)picSize.Width() / mImg->Width;
    double zoomy = (double)picSize.Height() / mImg->Height;
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    mImg->Draw(hdc, zoomx, zoomy, 0, 0);
    mRoi->Draw(hdc, true, zoomx, zoomy, 0, 0);
    mMatchResults->DrawAll(hdc, LPVPatDrawDefault, zoomx, zoomy, 0, 0);
    
    // release DC
    this->releaseDC(hdc);
}

C#

protected override void OnPaint(PaintEventArgs e)
{
    // balabala, other painting logic
    
    // adapt to size of ui widget
    double zoomX = (double)ClientRectangle.Width / m_img.Width;
    double zoomY = (double)ClientRectangle.Height / m_img.Height;
    
    // device context for painting
    IntPtr hdc = e.Graphics.GetHdc();
    
    e.Graphics.Clear(Color.White); // white background
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    m_img.Draw(hdc, zoomX, zoomY);
    m_roi.Draw(hdc, true, zoomX, zoomY);
    m_match_results.DrawAll(hdc, LPVPatDrawFlags.LPVPatDrawDefault, zoomX, zoomY);
    
    // balabala, other painting logic
    
    // at the end, release handle to device context.
    e.Graphics.ReleaseHdc(hdc);
    
    // Note, when the things you want to draw changed:
    // you may call Invalidate() to request a delayed repaint by the message loop system.
    // you may call Update() to force a immediate repaint.
    // you may use some flags to control which LPV objects should be drawn.
    // you may enable double-buffering for your form to avoid flickering.
}

COM

void CMFCDlg::OnPaint()
{
    // balabala, other painting logic
    
    CPaintDC dc(this); // device context for painting
    HDC hdc = dc.GetSafeHdc();
    
    CRect picRect;
    GetClientRect(picRect);
    
    // adapt to size of ui widget
    double zoomx = (double)picRect.Width() / m_img->Width;
    double zoomy = (double)picRect.Height() / m_img->Height;
    
    // white background
    FillRect(hdc, &picRect, (HBRUSH)GetStockObject(WHITE_BRUSH));
    
    // call draw function to draw the image and the match results on the bitmap
    // use 0, 0 panning 
    m_img->Draw(hdc, zoomx, zoomy, 0, 0);
    m_roi->Draw(hdc, VARIANT_TRUE, zoomx, zoomy, 0, 0);
    m_matchResults->DrawAll(hdc, LPVPatDrawDefault, zoomx, zoomy, 0, 0);
    
    // balabala, other painting logic
       CDialogEx::OnPaint();
    
    // Note, when the things you want to draw changed:
    // you may call Invalidate() to request a delayed repaint by the message loop system.
    // you may call UpdateWindow() to force a immediate repaint.
    // you may use some flags to control which LPV objects should be drawn.
    // you may use double-buffering technique to avoid flickering,
    // by painting the objects on an in-memory DC first then copying the entire canvas to the target DC.
}