Direct2D drawing quality is inconsistent

HoWe Yu 41

This is the result drawn in the window(HwndRenderTarget)

This is the result of drawing in WicBitmapRenderTarget

Viorel 114K Reputation points

2024-06-17T04:46:24.79+00:00

Maybe the image characteristics (pixel format, palette, size) are insuficient.
HoWe Yu 41 Reputation points

2024-06-17T05:37:04.7133333+00:00

I used two official Microsoft samples: Direct2DCircle and SaveAsImageFileSample, which only changed the drawing content to a straight line.

https://github.com/microsoft/Windows-classic-samples/tree/main/Samples/Win7Samples/begin/LearnWin32/Direct2DCircle

https://github.com/microsoft/windows-classic-samples/tree/main/Samples/Win7Samples/multimedia/Direct2D/SaveAsImageFileSample
Jeanine Zhang-MSFT 9,431 Reputation points Microsoft Vendor

2024-06-17T09:03:34.44+00:00

As far as I'm concerned, the reason is that there are differences between ID2D1Bitmap and IWicBitmap.I suggest you could refer to the Doc: Bitmap Sources Overview
Viorel 114K Reputation points

2024-06-17T11:00:17.8533333+00:00

How to reproduce efficiently the problem in case of SaveAsImageFileSample? What line did you drawn?

HoWe Yu 41

I rewrote two pieces of code, one to draw on the screen, and one to draw the image and save it

#include <d2d1.h>
#include <wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "windowscodecs.lib")

using D2D1::ColorF;
using D2D1::Point2F;

int main()
{
    CoInitialize(nullptr);

    IWICImagingFactory* wicFactory = nullptr;
    ID2D1Factory* d2dFactory = nullptr;

    IWICBitmap* wicBitmap = nullptr;
    ID2D1RenderTarget* renderTarget = nullptr;
    ID2D1SolidColorBrush* brush = nullptr;

    IWICBitmapEncoder* encoder = nullptr;
    IWICBitmapFrameEncode* frameEncode = nullptr;
    IWICStream* stream = nullptr;

    CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (void**)&wicFactory);
    D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);

    wicFactory->CreateBitmap(120, 40, GUID_WICPixelFormat32bppBGR, WICBitmapCacheOnLoad, &wicBitmap);
    d2dFactory->CreateWicBitmapRenderTarget(wicBitmap, D2D1::RenderTargetProperties(), &renderTarget);
    renderTarget->CreateSolidColorBrush(ColorF(ColorF::Black), &brush);

    renderTarget->BeginDraw();
    renderTarget->Clear(ColorF(ColorF::White));
    renderTarget->DrawLine(Point2F(20, 20.5), Point2F(100, 21.5), brush);
    renderTarget->EndDraw();

    wicFactory->CreateStream(&stream);
    const WCHAR filename[] = L"output.png";
    stream->InitializeFromFilename(filename, GENERIC_WRITE);

    wicFactory->CreateEncoder(GUID_ContainerFormatPng, NULL, &encoder);
    encoder->Initialize(stream, WICBitmapEncoderNoCache);
    encoder->CreateNewFrame(&frameEncode, NULL);

    frameEncode->Initialize(NULL);
    frameEncode->SetSize(120, 40);
    WICPixelFormatGUID format = GUID_WICPixelFormatDontCare;
    frameEncode->SetPixelFormat(&format);
    frameEncode->WriteSource(wicBitmap, NULL);
    frameEncode->Commit();

    encoder->Commit();

    return 0;
}

#include <d2d1.h>
#include <wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "windowscodecs.lib")

using D2D1::ColorF;
using D2D1::Point2F;

int main()
{
    CoInitialize(nullptr);

    IWICImagingFactory* wicFactory = nullptr;
    ID2D1Factory* d2dFactory = nullptr;

    IWICBitmap* wicBitmap = nullptr;
    ID2D1RenderTarget* renderTarget = nullptr;
    ID2D1SolidColorBrush* brush = nullptr;

    IWICBitmapEncoder* encoder = nullptr;
    IWICBitmapFrameEncode* frameEncode = nullptr;
    IWICStream* stream = nullptr;

    CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (void**)&wicFactory);
    D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);

    wicFactory->CreateBitmap(120, 40, GUID_WICPixelFormat32bppBGR, WICBitmapCacheOnLoad, &wicBitmap);
    d2dFactory->CreateWicBitmapRenderTarget(wicBitmap, D2D1::RenderTargetProperties(), &renderTarget);
    renderTarget->CreateSolidColorBrush(ColorF(ColorF::Black), &brush);

    renderTarget->BeginDraw();
    renderTarget->Clear(ColorF(ColorF::White));
    renderTarget->DrawLine(Point2F(20, 20.5), Point2F(100, 21.5), brush);
    renderTarget->EndDraw();

    wicFactory->CreateStream(&stream);
    const WCHAR filename[] = L"output.png";
    stream->InitializeFromFilename(filename, GENERIC_WRITE);

    wicFactory->CreateEncoder(GUID_ContainerFormatPng, NULL, &encoder);
    encoder->Initialize(stream, WICBitmapEncoderNoCache);
    encoder->CreateNewFrame(&frameEncode, NULL);

    frameEncode->Initialize(NULL);
    frameEncode->SetSize(120, 40);
    WICPixelFormatGUID format = GUID_WICPixelFormatDontCare;
    frameEncode->SetPixelFormat(&format);
    frameEncode->WriteSource(wicBitmap, NULL);
    frameEncode->Commit();

    encoder->Commit();

    return 0;
}

Jeanine Zhang-MSFT 9,431 Reputation points Microsoft Vendor

2024-06-18T06:54:28.56+00:00

I test the code that you provided, and I couldn't see the difference between them.

A WIC bitmap render target is an ID2D1RenderTarget that is created by one of the ID2D1Factory::CreateWicBitmapRenderTarget methods. As far as I'm concerned, the loss of drawing quality may occur during the conversion process.
HoWe Yu 41 Reputation points

2024-06-18T08:12:21.5866667+00:00

The code I wrote here is wrong and cannot be deleted. Please use the code in the answer. In addition, you need to enlarge the result to see the difference. The picture above is enlarged 4 times

Accepted answer

Castorix31 82,751

See MSDN :"Note that WIC bitmap render targets do not support hardware rendering."

You use D2D1_RENDER_TARGET_TYPE_HARDWARE in first sample and D2D1_RENDER_TARGET_TYPE_SOFTWARE in second sample

If you force D2D1_RENDER_TARGET_TYPE_SOFTWARE in first sample, you will get the same result as with WIC

(and you use old Direct2D code, use Direct2D device context method instead...)

HoWe Yu 41

After 7 hours of work, I finally succeeded in using ID2D1DeviceContext to draw pictures and export them as PNG, but the drawing results are incorrect.

#include <d2d1.h>
#include <d2d1_1.h>
#include <d3d11.h>
#include <wincodec.h>
#include <wrl/client.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "windowscodecs.lib")

using D2D1::ColorF;
using D2D1::Point2F;

using namespace Microsoft::WRL;

int main()
{
	UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;

	D3D_FEATURE_LEVEL featureLevels[] =
	{
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
		D3D_FEATURE_LEVEL_9_3,
		D3D_FEATURE_LEVEL_9_2,
		D3D_FEATURE_LEVEL_9_1
	};
	D3D_FEATURE_LEVEL levels;

	ID3D11Device* device;
	ID3D11DeviceContext* context;

	D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, 0, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &device, &levels, &context);

	IDXGIDevice* dxgiDevice;
	device->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);

	ID2D1Factory1* d2dFactory = nullptr;
	D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);

	ID2D1Device* d2d1Device;
	d2dFactory->CreateDevice(dxgiDevice, &d2d1Device);

	ID2D1DeviceContext* deviceContext;
	d2d1Device->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &deviceContext);

	D2D1_BITMAP_PROPERTIES1 properties = D2D1::BitmapProperties1(
		D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
		D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE)
	);

	ID2D1Bitmap1* bitmapForRender;
	D2D1_SIZE_U size = D2D1::SizeU(200, 200);
	HRESULT hr = deviceContext->CreateBitmap(size, nullptr, 0, &properties, &bitmapForRender);

	ID2D1Bitmap1* bitmapForRead;
	properties = D2D1::BitmapProperties1(
		D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ,
		D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE)
	);
	hr = deviceContext->CreateBitmap(size, nullptr, 0, &properties, &bitmapForRead);

	deviceContext->SetTarget(bitmapForRender);

	deviceContext->BeginDraw();
	deviceContext->Clear(ColorF(ColorF::YellowGreen));
	deviceContext->EndDraw();

	UINT bufferSize = size.width * size.height * 4;
	BYTE* pixelData = new BYTE[bufferSize];

	D2D1_POINT_2U point{ 0,0 };
	D2D1_RECT_U rect{ 0,0,200,200 };
	hr = bitmapForRead->CopyFromBitmap(&point, bitmapForRender, &rect);

	D2D1_MAPPED_RECT mappedRect;
	hr = bitmapForRead->Map(D2D1_MAP_OPTIONS_READ, &mappedRect);
	memcpy(pixelData, mappedRect.bits, bufferSize);
	hr = bitmapForRead->Unmap();

	CoInitializeEx(nullptr, COINIT_MULTITHREADED);

	ComPtr<IWICImagingFactory> wicFactory;
	CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&wicFactory));

	ComPtr<IWICBitmap> wicBitmap;
	hr = wicFactory->CreateBitmapFromMemory(200, 200, GUID_WICPixelFormat32bppBGRA, 800, bufferSize, pixelData, &wicBitmap);

	ComPtr<IWICStream> wicStream;
	hr = wicFactory->CreateStream(&wicStream);
	hr = wicStream->InitializeFromFilename(L"output.png", GENERIC_WRITE);

	ComPtr<IWICBitmapEncoder> pngEncoder;
	hr = wicFactory->CreateEncoder(GUID_ContainerFormatPng, nullptr, &pngEncoder);
	hr = pngEncoder->Initialize(wicStream.Get(), WICBitmapEncoderNoCache);

	ComPtr<IWICBitmapFrameEncode> frameEncode;
	hr = pngEncoder->CreateNewFrame(&frameEncode, nullptr);

	hr = frameEncode->Initialize(nullptr);
	hr = frameEncode->SetSize(size.width, size.height);
	WICPixelFormatGUID format = GUID_WICPixelFormat32bppBGRA;
	hr = frameEncode->SetPixelFormat(&format);
	hr = frameEncode->WriteSource(wicBitmap.Get(), nullptr);

	hr = frameEncode->Commit();
	hr = pngEncoder->Commit();

	return 0;
}

output

Viorel 114K

Try this modification:

UINT bufferSize = mappedRect.pitch * size.height;
BYTE* pixelData = new BYTE[bufferSize];
memcpy( pixelData, mappedRect.bits, bufferSize );

Use mappedRect.pitch instead of 800.

Castorix31 82,751 Reputation points

2024-06-18T17:17:08.6866667+00:00

You don't need to read bitmap bits

Just use IWICImageEncoder::WriteFrame like in MSDN sample : https://video2.skills-academy.com/en-us/windows/win32/direct2d/save-direct2d-content-to-an-image-file

1 additional answer

HoWe Yu 41

#include <d2d1.h>
#include <wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "windowscodecs.lib")

using D2D1::ColorF;
using D2D1::Point2F;

int main()
{
	ID2D1Factory* factory;
	D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &factory);

	ID2D1DCRenderTarget* renderTarget;
	D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
		D2D1_RENDER_TARGET_TYPE_DEFAULT,
		D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE),
		0, 0, D2D1_RENDER_TARGET_USAGE_NONE, D2D1_FEATURE_LEVEL_DEFAULT
	);
	factory->CreateDCRenderTarget(&props, &renderTarget);

	HDC hdc = GetDC(NULL);
	RECT rect{ 0, 0, 120, 40 };
	renderTarget->BindDC(hdc, &rect);

	ID2D1SolidColorBrush* brush = nullptr;
	renderTarget->CreateSolidColorBrush(ColorF(ColorF::Black), &brush);

	renderTarget->BeginDraw();
	renderTarget->Clear(ColorF(ColorF::White));
	renderTarget->DrawLine(Point2F(20, 20.5), Point2F(100, 21.5), brush);
	// Insert breakpoint here to view the drawing results
	renderTarget->EndDraw();

	if (renderTarget) renderTarget->Release();
	if (factory) factory->Release();

	return 0;
}

#include <d2d1.h>
#include <wincodec.h>

#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "windowscodecs.lib")

using D2D1::ColorF;
using D2D1::Point2F;

int main()
{
    CoInitialize(nullptr);

    IWICImagingFactory* wicFactory = nullptr;
    ID2D1Factory* d2dFactory = nullptr;

    IWICBitmap* wicBitmap = nullptr;
    ID2D1RenderTarget* renderTarget = nullptr;
    ID2D1SolidColorBrush* brush = nullptr;

    IWICBitmapEncoder* encoder = nullptr;
    IWICBitmapFrameEncode* frameEncode = nullptr;
    IWICStream* stream = nullptr;

    CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (void**)&wicFactory);
    D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2dFactory);

    wicFactory->CreateBitmap(120, 40, GUID_WICPixelFormat32bppBGR, WICBitmapCacheOnLoad, &wicBitmap);
    d2dFactory->CreateWicBitmapRenderTarget(wicBitmap, D2D1::RenderTargetProperties(), &renderTarget);
    renderTarget->CreateSolidColorBrush(ColorF(ColorF::Black), &brush);

    renderTarget->BeginDraw();
    renderTarget->Clear(ColorF(ColorF::White));
    renderTarget->DrawLine(Point2F(20, 20.5), Point2F(100, 21.5), brush);
    renderTarget->EndDraw();

    wicFactory->CreateStream(&stream);
    const WCHAR filename[] = L"output.png";
    stream->InitializeFromFilename(filename, GENERIC_WRITE);

    wicFactory->CreateEncoder(GUID_ContainerFormatPng, NULL, &encoder);
    encoder->Initialize(stream, WICBitmapEncoderNoCache);
    encoder->CreateNewFrame(&frameEncode, NULL);

    frameEncode->Initialize(NULL);
    frameEncode->SetSize(120, 40);
    WICPixelFormatGUID format = GUID_WICPixelFormatDontCare;
    frameEncode->SetPixelFormat(&format);
    frameEncode->WriteSource(wicBitmap, NULL);
    frameEncode->Commit();

    encoder->Commit();

    return 0;
}

HoWe Yu 41 Reputation points

2024-06-17T13:12:07.1266667+00:00

I wrote two pieces of code to reproduce the problem
HoWe Yu 41 Reputation points

2024-06-17T13:19:06.5+00:00

I wrote two pieces of code to reproduce the problem

Share via

Direct2D drawing quality is inconsistent

1 additional answer