Comparer: pink-dot grid overlay for pixel-level diffs (#13)

The image area in each pane is divided into a fixed-size grid in
display pixels. Every cell that contains at least one pixel that
differs from the reference pane is highlighted with a translucent pink
rectangle outline plus a center dot, drawn with GDI+ alpha blending so
the underlying image stays visible. Because the cell size is fixed in
display pixels, zooming in implicitly subdivides the source region each
cell covers — at maximum zoom each dot resolves to a single differing
source pixel.

'D' toggles the overlay on and off (default on).

Per-row red diff lines in PosInfoView are removed (the grid overlay
covers the same information). The timeline is hidden when neither pane
is a video; frame picking is still available for video sources.

Author: chammoru

Comparer/Comparer.cpp

@@ -9,6 +9,9 @@
 
 #include "ComparerDoc.h"
 
+#include <gdiplus.h>
+#pragma comment(lib, "gdiplus.lib")
+
 #ifdef _DEBUG
 #define new DEBUG_NEW
 #endif
@@ -62,6 +65,9 @@ BOOL CComparerApp::InitInstance()
 {
 	CWinApp::InitInstance();
 
+	Gdiplus::GdiplusStartupInput gdiplusStartupInput;
+	Gdiplus::GdiplusStartup(&mGdiplusToken, &gdiplusStartupInput, NULL);
+
 	SetRegistryKey(_T("Chammoru"));
 	LoadStdProfileSettings(4);  // Load standard INI file options (including MRU)
 
@@ -108,6 +114,12 @@ BOOL CComparerApp::InitInstance()
 	return TRUE;
 }
 
+int CComparerApp::ExitInstance()
+{
+	Gdiplus::GdiplusShutdown(mGdiplusToken);
+	return CWinApp::ExitInstance();
+}
+
 
 
 // CAboutDlg dialog used for App About

Comparer/Comparer.h

@@ -24,11 +24,15 @@ class CComparerApp : public CWinApp
 // Overrides
 public:
 	virtual BOOL InitInstance();
+	virtual int ExitInstance();
 
 // Implementation
 	afx_msg void OnAppAbout();
 	DECLARE_MESSAGE_MAP()
 	afx_msg void OnFileOpen();
+
+private:
+	ULONG_PTR mGdiplusToken;
 };
 
 extern CComparerApp theApp;

Comparer/ComparerDoc.cpp

@@ -64,6 +64,7 @@ CComparerDoc::CComparerDoc()
 , mFps(COMPARER_DEF_FPS)
 , mInterpol(false)
 , mDiffRes(false)
+, mDiffOverlay(true)
 {
 	BITMAPINFOHEADER &bmiHeader = mBmi.bmiHeader;
 	bmiHeader.biSize = (DWORD)sizeof(BITMAPINFOHEADER);

Comparer/ComparerDoc.h

@@ -79,6 +79,7 @@ class CComparerDoc : public CDocument
 	double mFps;
 	bool mInterpol;
 	bool mDiffRes;
+	bool mDiffOverlay;
 
 // Operations
 public:

Comparer/ComparerView.cpp

@@ -16,6 +16,8 @@
 #include <QViewerCmn.h>
 #include <QImageStr.h>
 
+#include <gdiplus.h>
+
 // CComparerView
 
 CComparerView::CComparerView()
@@ -242,11 +244,104 @@ void CComparerView::OnDraw(CDC *pDC)
 		}
 	}
 
+	DrawDiffOverlay(&memDC, pDoc, pane);
+
 	pDC->BitBlt(0, mRcControls.bottom, mWCanvas, mHCanvas, &memDC, 0, 0, SRCCOPY);
 
 	mProcessing = false;
 }
 
+// Pilot: draw a semi-transparent pink cell outline + center dot in every
+// grid cell that contains at least one pixel that differs from the reference
+// pane. Cell size is fixed in display pixels, so zooming in implicitly
+// subdivides the source region each cell covers — at maximum zoom each dot
+// resolves to a single differing source pixel.
+void CComparerView::DrawDiffOverlay(CDC *pDC, CComparerDoc *pDoc, ComparerPane *pane)
+{
+	if (!pDoc->mDiffOverlay)
+		return;
+	if (!pane || !pane->isAvail() || !pane->rgbBuf)
+		return;
+
+	// Find any other available pane to compare against (pilot assumes 2 panes).
+	ComparerPane *other = nullptr;
+	for (int i = 0; i < CComparerDoc::IMG_VIEW_MAX; i++) {
+		ComparerPane *p = &pDoc->mPane[i];
+		if (p == pane)
+			continue;
+		if (p->isAvail() && p->rgbBuf) {
+			other = p;
+			break;
+		}
+	}
+	if (!other || pDoc->mW <= 0 || pDoc->mH <= 0)
+		return;
+
+	const int rowBytes = ROUNDUP_DWORD(pDoc->mW) * QIMG_DST_RGB_BYTES;
+	const BYTE *bufA = pane->rgbBuf;
+	const BYTE *bufB = other->rgbBuf;
+
+	const int cellPx = 48;   // grid cell size in display pixels
+	const int dotR   = 3;    // center dot radius
+
+	Gdiplus::Graphics g(pDC->m_hDC);
+	g.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
+	g.SetCompositingMode(Gdiplus::CompositingModeSourceOver);
+
+	const Gdiplus::Color cellColor(200, 0xff, 0x3d, 0x8a);   // ~78% alpha pink
+	const Gdiplus::Color dotColor (235, 0xff, 0x3d, 0x8a);   // ~92% alpha pink
+	Gdiplus::Pen        cellPen(cellColor, 1.0f);
+	cellPen.SetAlignment(Gdiplus::PenAlignmentInset);
+	Gdiplus::SolidBrush dotBrush(dotColor);
+
+	const float invN = (pDoc->mN > 0.0f) ? (1.0f / pDoc->mN) : 1.0f;
+
+	for (int cy = 0; cy < mHCanvas; cy += cellPx) {
+		int cellBot = cy + cellPx;
+		if (cellBot > mHCanvas) cellBot = mHCanvas;
+
+		int sy0 = (int)floorf((cy      - mYDst) * invN);
+		int sy1 = (int)ceilf ((cellBot - mYDst) * invN);
+		if (sy0 < 0)         sy0 = 0;
+		if (sy1 > pDoc->mH)  sy1 = pDoc->mH;
+		if (sy0 >= sy1)      continue;
+
+		for (int cx = 0; cx < mWCanvas; cx += cellPx) {
+			int cellRight = cx + cellPx;
+			if (cellRight > mWCanvas) cellRight = mWCanvas;
+
+			int sx0 = (int)floorf((cx        - mXDst) * invN);
+			int sx1 = (int)ceilf ((cellRight - mXDst) * invN);
+			if (sx0 < 0)        sx0 = 0;
+			if (sx1 > pDoc->mW) sx1 = pDoc->mW;
+			if (sx0 >= sx1)     continue;
+
+			bool hasDiff = false;
+			const int byteStart = sx0 * QIMG_DST_RGB_BYTES;
+			const int byteLen   = (sx1 - sx0) * QIMG_DST_RGB_BYTES;
+			for (int sy = sy0; sy < sy1; sy++) {
+				const BYTE *ra = bufA + sy * rowBytes + byteStart;
+				const BYTE *rb = bufB + sy * rowBytes + byteStart;
+				if (memcmp(ra, rb, byteLen) != 0) {
+					hasDiff = true;
+					break;
+				}
+			}
+
+			if (hasDiff) {
+				g.DrawRectangle(&cellPen,
+					(float)cx, (float)cy,
+					(float)(cellRight - cx - 1), (float)(cellBot - cy - 1));
+
+				float dotX = (cx + cellRight) * 0.5f;
+				float dotY = (cy + cellBot)   * 0.5f;
+				g.FillEllipse(&dotBrush,
+					dotX - dotR, dotY - dotR, 2.0f * dotR, 2.0f * dotR);
+			}
+		}
+	}
+}
+
 void CComparerView::DrawEmptyPane(CDC *pDC, CComparerDoc *pDoc)
 {
 	CRect canvas(0, mRcControls.bottom, mWClient, mHClient);
@@ -678,6 +773,9 @@ void CComparerView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
 		pDoc->mInterpol = !pDoc->mInterpol;
 		Invalidate(FALSE);
 		break;
+	case 'D':
+		pDoc->mDiffOverlay = !pDoc->mDiffOverlay;
+		break;
 	}
 
 	// Most shortcuts affect shared document/view state, so refresh once at the end.

Comparer/ComparerView.h

@@ -57,6 +57,7 @@ class CComparerView : public CScrollView
 	void ScaleNearestNeighbor(CComparerDoc *pDoc, BYTE *src, BYTE *dst, int sDst,
 		q1::GridInfo &gi);
 	void DrawEmptyPane(CDC *pDC, CComparerDoc *pDoc);
+	void DrawDiffOverlay(CDC *pDC, CComparerDoc *pDoc, ComparerPane *pane);
 
 	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 	afx_msg void OnDropFiles(HDROP hDropInfo);

Comparer/PosInfoView.cpp

@@ -59,21 +59,6 @@ void CPosInfoView::OnInitialUpdate()
 	CScrollView::OnInitialUpdate();
 }
 
-static void DrawDiffPosLines(CDC *pDC, CRect *frameRect, bool *flags, int n)
-{
-	int top = frameRect->top + 1;
-	int left = frameRect->left + 1;
-	int right = frameRect->right - 1;
-
-	for (int i = 0; i < n; i++) {
-		if (flags[i] == false)
-			continue;
-
-		pDC->MoveTo(left, top + i);
-		pDC->LineTo(right, top + i);
-	}
-}
-
 void CPosInfoView::DrawEachRect(CDC* pDC,
 								ComparerPane *pane,
 								CRect *frameRect,
@@ -98,17 +83,9 @@ void CPosInfoView::DrawEachRect(CDC* pDC,
 	pDC->FillSolidRect(frameRect, frameColor);
 	pDC->Draw3dRect(frameRect, Q1UI_COLOR_SURFACE, Q1UI_COLOR_SURFACE);
 
-	if (parseDone) {
-		CPen *prev = pDC->SelectObject(mDiffPen);
-		IFrmCmpStrategy *frmCmpStrategy = pDoc->mFrmCmpStrategy;
-		list<RLC> diffRLC[QPLANES];
-
-		if (mFileScanThread->copyDiffRLC(i, diffRLC)) {
-			frmCmpStrategy->FlagTotalDiffLine(diffRLC, mDiffFlags, mPosLinesPerFrame);
-			DrawDiffPosLines(pDC, frameRect, mDiffFlags, mPosLinesPerFrame);
-		}
-		pDC->SelectObject(prev);
-	}
+	// Per-row red diff lines have been replaced by the pink grid overlay in
+	// ComparerView. Pilot keeps the frame tiles for video-frame selection but
+	// no longer draws the per-row indicators.
 
 	const COLORREF curIdColor = Q1UI_COLOR_ACCENT;
 	COLORREF preColor;
@@ -183,7 +160,13 @@ void CPosInfoView::OnDraw(CDC* pDC)
 
 	memDC.FillSolidRect(CRect(0, 0, mWClient, h), Q1UI_COLOR_APP_BG);
 
-	if (!paneL->isAvail() && !paneR->isAvail()) {
+	// Pilot: hide the timeline entirely when neither pane is a video. The pink
+	// grid overlay in ComparerView already conveys diff information; the
+	// timeline is only useful for picking a frame in a video source.
+	bool hasVideo = (paneL->isAvail() && paneL->frames > 1)
+	             || (paneR->isAvail() && paneR->frames > 1);
+
+	if (!paneL->isAvail() && !paneR->isAvail() || !hasVideo) {
 		LOGFONT lf;
 		mPosNumFont.GetLogFont(&lf);
 		::lstrcpy(lf.lfFaceName, Q1UI_FONT_TEXT);
@@ -195,7 +178,10 @@ void CPosInfoView::OnDraw(CDC* pDC)
 		memDC.SetBkMode(TRANSPARENT);
 		memDC.SetTextColor(Q1UI_COLOR_TEXT_MUTED);
 		CRect msgRect(0, 0, mWClient, h);
-		memDC.DrawText(_T("Timeline"), &msgRect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
+		LPCTSTR msg = (paneL->isAvail() || paneR->isAvail())
+			? _T("Timeline\n(video only)") : _T("Timeline");
+		memDC.DrawText(msg, &msgRect,
+			DT_CENTER | DT_VCENTER | DT_WORDBREAK | DT_NOCLIP);
 		memDC.SelectObject(prevFont);
 		goto OnDrawExit;
 	}