GraphicsContext does not use alpha channel properly when rendering fonts/text

[kdschlosser]

Operating system: MSW 7 x64
wxPython version & source: 4.1.0 msw (phoenix) wxWidgets 3.1.4, pypi
Python version & source: 3.7.5 Stackless 3.7 (tags/v3.7.5-slp:f7925f2a02, Oct 20 2019, 15:28:53) [MSC v.1916 64 bit (AMD64)]

Description of the problem: when rendering text using a GraphicsContext instance the alpha channel causes a change in the brightness but not a change in opacity

Code Example (MSW only)

import ctypes.wintypes
import ctypes
import wx

HANDLE = ctypes.wintypes.HANDLE
LPWSTR = ctypes.wintypes.LPWSTR
HRESULT = ctypes.HRESULT
LONG = ctypes.wintypes.LONG
HWND = ctypes.wintypes.HWND
INT = ctypes.wintypes.INT
HDC = ctypes.wintypes.HDC
HGDIOBJ = ctypes.wintypes.HGDIOBJ
BOOL = ctypes.wintypes.BOOL
DWORD = ctypes.wintypes.DWORD
UBYTE = ctypes.c_ubyte
COLORREF = DWORD

GWL_EXSTYLE = -20
WS_EX_LAYERED = 0x00080000
ULW_ALPHA = 0x00000002
AC_SRC_OVER = 0x00000000
AC_SRC_ALPHA = 0x00000001


def RGB(r, g, b):
    return COLORREF(r | (g << 8) | (b << 16))


class POINT(ctypes.Structure):
    _fields_ = [
        ('x', LONG),
        ('y', LONG)
    ]


class SIZE(ctypes.Structure):
    _fields_ = [
        ('cx', LONG),
        ('cy', LONG)
    ]


class BLENDFUNCTION(ctypes.Structure):
    _fields_ = [
        ('BlendOp', UBYTE),
        ('BlendFlags', UBYTE),
        ('SourceConstantAlpha', UBYTE),
        ('AlphaFormat', UBYTE)
    ]

byref = ctypes.byref

kernel32 = ctypes.windll.Kernel32

GetTempPathW = kernel32.GetTempPathW
GetTempPathW.restype = DWORD
GetTempPathW.argtypes = [DWORD, LPWSTR]


gdi32 = ctypes.windll.Gdi32

# HDC CreateCompatibleDC(
#   HDC hdc
# );
CreateCompatibleDC = gdi32.CreateCompatibleDC
CreateCompatibleDC.restype = HDC

# HGDIOBJ SelectObject(
#   HDC     hdc,
#   HGDIOBJ h
# );
SelectObject = gdi32.SelectObject
SelectObject.restype = HGDIOBJ

# BOOL DeleteDC(
#   HDC hdc
# );

DeleteDC = gdi32.DeleteDC
DeleteDC.restype = BOOL


shell32 = ctypes.windll.Shell32

SHGetFolderPathW = shell32.SHGetFolderPathW
SHGetFolderPathW.restype = HRESULT
SHGetFolderPathW.argtypes = [HWND, INT, HANDLE, DWORD, LPWSTR]


user32 = ctypes.windll.User32

# LONG GetWindowLongW(
#   HWND hWnd,
#   int  nIndex
# )

GetWindowLongW = user32.GetWindowLongW
GetWindowLongW.restype = LONG

# LONG SetWindowLongW(
#   HWND hWnd,
#   int  nIndex,
#   LONG dwNewLong
# );
SetWindowLongW = user32.SetWindowLongW
SetWindowLongW.restype = LONG

# HDC GetDC(
#   HWND hWnd
# );
GetDC = user32.GetDC
GetDC.restype = HDC

# HWND GetDesktopWindow();
GetDesktopWindow = user32.GetDesktopWindow
GetDesktopWindow.restype = HWND

# BOOL UpdateLayeredWindow(
#   HWND          hWnd,
#   HDC           hdcDst,
#   POINT         *pptDst,
#   SIZE          *psize,
#   HDC           hdcSrc,
#   POINT         *pptSrc,
#   COLORREF      crKey,
#   BLENDFUNCTION *pblend,
#   DWORD         dwFlags
# );
UpdateLayeredWindow = user32.UpdateLayeredWindow
UpdateLayeredWindow.restype = BOOL

import math


class AlphaFrame(wx.Frame):
    _xml = None
    _vehicle = None

    def __init__(self, parent=None, size=(800, 800), style=wx.TRANSPARENT_WINDOW):
        wx.Frame.__init__(
            self,
            parent,
            -1,
            style=(
                wx.NO_BORDER |
                wx.FRAME_NO_TASKBAR |
                style
            )
        )

        self.SetSize(size)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x: None)

    def Draw(self):
        width, height = self.GetClientSize()
        bmp = wx.Bitmap.FromRGBA(width, height)
        dc = wx.MemoryDC()
        dc.SelectObject(bmp)

        gc = wx.GraphicsContext.Create(dc)

        gc.SetPen(gc.CreatePen(wx.Pen(wx.Colour(255, 0, 0, 175), 10)))
        # gc.SetBrush(gc.CreateBrush(wx.Brush(wx.Colour(0, 0, 255, 100))))

        gc.DrawRoundedRectangle(20, 20, width - 40, height / 2, 5)

        text = 'This is a transparent frame'
        text_len = len(text)

        text_width, char_height = self.GetFullTextExtent(text)[:2]

        radius = (min(width, height) * 0.90) / 2

        circumference = radius * math.pi * 2
        angle_range = 320.0 - 190.0
        avg_char_width = text_width / text_len
        angle_ratio = angle_range / 360.0
        arc_length = circumference * angle_ratio
        num_steps = arc_length / avg_char_width
        angle_spacing = angle_range / num_steps

        pixels_per_degree = circumference / 360.0

        angle = 190.0 + (angle_spacing / 2)

        font = self.GetFont()
        font.SetStyle(wx.FONTSTYLE_ITALIC)
        font.MakeBold()
        font.SetFractionalPointSize(font.GetFractionalPointSize() * 3)
        gc.SetFont(font, wx.Colour(0, 0, 0, 1))

        center_x = width / 2.0
        center_y = height / 2.0

        for char in list(text):
            char_width = gc.GetFullTextExtent(char)[0]
            angle_offset = (char_width / 2) / pixels_per_degree

            spacing = (angle_range / text_len) + angle_offset

            for _ in range(2):
                radians = math.radians(angle - angle_offset)

                cos = math.cos(radians)
                sin = math.sin(radians)
                x = center_x + (radius * cos)
                y = center_y + (radius * sin)

                text_radians = math.radians(angle - angle_offset + 90.0)

                gc.DrawText(char, x, y, -text_radians)
                angle_offset -= 0.3

            angle += spacing

        angle = 190.0 + (angle_spacing / 2)
        gc.SetFont(font, wx.Colour(0, 255, 0, 200))

        for char in list(text):

            char_width = gc.GetFullTextExtent(char)[0]
            angle_offset = (char_width / 2) / pixels_per_degree

            spacing = (angle_range / text_len) + angle_offset
            radians = math.radians(angle - angle_offset - 1)

            cos = math.cos(radians)
            sin = math.sin(radians)
            x = center_x + (radius * cos)
            y = center_y + (radius * sin)

            text_radians = math.radians(angle - angle_offset + 90.0)

            gc.DrawText(char, x, y, -text_radians)

            angle += spacing

        dc.SelectObject(wx.NullBitmap)
        gc.Destroy()
        del gc

        dc.Destroy()
        del dc

        self.Render(bmp)


    def Render(self, bmp, transparency=255):
        x, y = self.GetPosition()
        hndl = self.GetHandle()
        style = GetWindowLongW(HWND(hndl), INT(GWL_EXSTYLE))
        SetWindowLongW(HWND(hndl), INT(GWL_EXSTYLE), LONG(style | WS_EX_LAYERED))

        hdcDst = GetDC(GetDesktopWindow())
        hdcSrc = CreateCompatibleDC(HDC(hdcDst))

        pptDst = POINT(int(x), int(y))
        psize = SIZE(bmp.GetWidth(), bmp.GetHeight())
        pptSrc = POINT(0, 0)
        crKey = RGB(0, 0, 0)

        pblend = BLENDFUNCTION(AC_SRC_OVER, 0, transparency, AC_SRC_ALPHA)

        SelectObject(HDC(hdcSrc), HGDIOBJ(bmp.GetHandle()))
        UpdateLayeredWindow(
            HWND(hndl),
            HDC(hdcDst),
            byref(pptDst),
            byref(psize),
            HDC(hdcSrc),
            byref(pptSrc),
            crKey,
            byref(pblend),
            DWORD(ULW_ALPHA)
        )

        DeleteDC(HDC(hdcDst))
        DeleteDC(HDC(hdcSrc))


app = wx.App()

frame = AlphaFrame()
frame.Show()
frame.Draw()
app.MainLoop()

[Metallicow]

I'm not exactly sure why it is giving me errors about sending a wx.GraphicsFont. It appears you got something screwed up since it is accepting a wx.Font.

1. I see that you are not using a PaintEvent.
2. You are using FromRGBA might be causing issues.
3. You are using a MemoryDC.

... so not exactly sure what the real problem is.

If you modify my TransparentPaintWindow Sample you can indeed see that the GraphicsFont alpha is working correctly.

I think somehow something got screwed up, since you are using your ctypes stuff...

[Metallicow]

Depending on the results you want, you can do like I did in the previous sample where I used your mswalpha for the transparent frame, and then create a 2nd float on parent frame for the mswalpha affected one and use a region for the text and then set the transparency on the frame. See this sample #1544 (comment)
That I think should allow you to use a PaintEvent and might work like you are expecting... Tho antialiasing may or may not work properly on the edges...

[kdschlosser]

You have to use FromRGBA otherwise the bitmap will not have an alpha channel... the MemoryDC is only being used for the purposes of selecting the bitmap. I am creating a GraphicsContext instance from the MemoryDC instance. This allows me to render to the bitmap using the Graphics context.

As you stated, The GraphicsContext.SetFont method should not be allowing a wxFont instance to be passed to it.

The only thing the ctypes stuff does is it draws the bitmap to the screen. That is it. The font is being rendered to the bitmap without an alpha channel and this is how it gets drawn on the screen by the ctypes stuff. The problem is NOT with that portion of the code.

There is a GraphicsContext.CreateFont method and I have tried using this as well but the results are exactly the same.

gc.SetFont(gc.CreateFont(font, wx.Colour(0, 255, 0, 100)))

I would have thought that this would utilize the alpha channel properly but it does not.

[Metallicow]

This old mailing list sample converted to phoenix might help.

Shaped Text Frame - Click to expand

import wx

class ShapedText(wx.Frame):
    def __init__(self, text="Scrolling text!"):
        wx.Frame.__init__(self, None, style=
                wx.FRAME_SHAPED | wx.NO_BORDER | wx.FRAME_NO_TASKBAR | wx.STAY_ON_TOP)

        if not self.IsDoubleBuffered():
            self.SetDoubleBuffered(True)  # Reduce flicker.

        # Set up the timer which will move the text and paint the screen.
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.OnTimer, source=self.timer)
        self.timer.Start(10)

        # Make sure we are using our custom paint handler.
        self.Bind(wx.EVT_PAINT, self.OnPaint)

        screenwidth = wx.SystemSettings.GetMetric(wx.SYS_SCREEN_X)
        screenheight = wx.SystemSettings.GetMetric(wx.SYS_SCREEN_Y)

        framewidth = int(screenheight * .75)
        frameheight = 100

        framex = int(screenwidth/2 - framewidth/2)
        framey = screenheight - 150

        # Create the bitmap.
        self.textFont = wx.Font(36, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL)
        self.bmp = wx.Bitmap(framewidth, frameheight)
        self.SetScrolledString(text)
        self.SetWindowShape()

        self.SetPosition((framex, framey))
        self.SetSize((framewidth, self.textHeight+5))

        self.SetTransparent(100)

    def SetScrolledString(self, txt):
        self.scrolledStr = txt
        self.textOffset = 0
        # Calculate the text width.
        memDC = wx.MemoryDC()
        memDC.SetFont(self.textFont)
        self.textWidth, self.textHeight, heightLine = memDC.GetFullMultiLineTextExtent(self.scrolledStr)
        memDC.Destroy()

    def SetWindowShape(self):
        # Use the bitmap's mask to determine the region.
        r = wx.Region(self.bmp)
        self.SetShape(r)

    def OnPaint(self, event):
        # Draw the bitmap on the screen.
        dc = wx.PaintDC(self)
        dc.DrawBitmap(self.bmp, 0, 0, useMask=True)

    def OnTimer(self, event):
        # Draw the text on the bitmap, set a mask, and paint.
        x, y = self.Size
        memDC = wx.MemoryDC(self.bmp)
        memDC.SetPen(wx.WHITE_PEN)
        memDC.DrawRectangle(0, 0, x, y)
        memDC.SetFont(self.textFont)
        memDC.DrawText(self.scrolledStr, x-self.textOffset, 0)
        memDC.Destroy()

        mask = wx.Mask(self.bmp, wx.WHITE)
        self.bmp.SetMask(mask)  # Comment this line to disable transparency.

        self.textOffset += 1

        # Stop the timer when the text has scrolled the entire way across.
        # print(self.textOffset-self.Size[0], self.textWidth)
        if self.textOffset - x == self.textWidth:
            # print(self.textOffset-self.Size[0], textWidth)
            self.timer.Stop()
            self.Destroy()

        self.SetWindowShape()
        self.Refresh()


if __name__ == "__main__":
    app = wx.App()
    frame = ShapedText()
    frame.Show(True)
    app.MainLoop()

[kdschlosser]

nope that is not going to support alpha channels

[RobinD42]

Some implementation details that may help, if you haven't already dug into the relevant C++ code: In the GDI+ GC backend the colour value is used to create a gdi+ SolidBrush, and that is then held by the wxGDIPlusFontData class along with the gdi+ Font object. The Font and Brush are then used when calling the gdi+ DrawString API. There really isn't a lot of complexity there, just a lot of little things working together to tie the two APIs together.

The alpha value is used when creating the brush, but I don't know why it wouldn't be using it. I do know that GDI+ has some holes in its functionality, perhaps drawing text with a partially transparent brush is one of them? Have you tried the Direct2D GC backend? If you're just interested in getting a bitmap out of this then using the Cairo backend would probably be an option as well.

[kdschlosser]

@RobinD42

I have also tried to wrap MemoryDC with GCDC and GraphicsContext with GCDC and the results are the same.
Now.. If I create a GraphicsContext instance from a PaintDC it does render properly.

I am guessing I am probably going to have to learn more about Cairo

[RobinD42]

The GCDC is still going to use the default renderer backend, which on Windows is GDI+, so I wouldn't expect any difference when using the GCDC vs what you were doing before. To use a non-default you need to explicitly create the renderer and then use it to create the GraphicsContext and related objects. For example, something like this:

        if 'wxMSW' in wx.PlatformInfo:
            renderer = wx.GraphicsRenderer.GetDirect2DRenderer() # or GetCairoRenderer
        else:
            renderer = wx.GraphicsRenderer.GetDefaultRenderer()
        ctx = renderer.CreateContext(dc)

If wanted, you can create the renderer once and reuse the same one throughout the application's lifetime.

There is also a module implementing a GraphicsContext-like in Python using Cairo, in wx.lib.Graphics. If you want to use the Cairo API directly then the wx.lib.wxcairo package provides some code to help you use Cairo on wx.DCs, wx.Bitmaps, etc.

[kdschlosser]

@RobinD42

If I use the Direct2D renderer as you have shown above. Nothing gets drawn.

[srirams]

I have the same issue (plus the text looks quite bad).

This is what it looks like (text is drawn on a WS_EX_LAYERED window, with a white window behind it)

To fix it, we have the use SetTextRenderingHint to TextRenderingHintAntiAliasGridFit. This fixes both the alpha channel not applying and the the text rendering.

Unfortunately I couldn't find a way to call SetTextRenderingHint in wx, so had to use a .dll with

extern "C" __declspec(dllexport) int SetTextRenderingHint(void* v, int renderingHint) {
	Gdiplus::Graphics* g = reinterpret_cast<Gdiplus::Graphics*>(v);
	return g->SetTextRenderingHint(static_cast<Gdiplus::TextRenderingHint>(renderingHint));
}

and ctypes in python

        stdc = ctypes.cdll.LoadLibrary(R"PyWxGdiPlus.dll")
        TextRenderingHintAntiAliasGridFit = 3
        r = stdc.SetTextRenderingHint(ctypes.c_void_p(gc.GetNativeContext().__int__()), TextRenderingHintAntiAliasGridFit)

edit: and I don't believe this is a wx bug, same problem happens using gdiplus directly.

[kdschlosser]

edit: and I don't believe this is a wx bug, same problem happens using gdiplus directly.

This is good to know.

You should be able to make those function calls without having to make a dll.

something along these lines.

import ctypes

GpStatus = ctypes.HRESULT


gdiplus = ctypes.windll.gdiplus
GdipSetTextRenderingHint = gdiplus.GdipSetTextRenderingHint
GdipSetTextRenderingHint.restype = GpStatus

and then in a paint event

TextRenderingHintAntiAliasGridFit = 3

def OnPaint(self, event):
    # Create paint DC
    dc = wx.PaintDC(self)

    # Create graphics context from it
    gc = wx.GraphicsContext.Create(dc)
    if gc:
        GdipSetTextRenderingHint(ctypes.byref(gc.GetNativeContext()), TextRenderingHintAntiAliasGridFit)

something like that. I have not tested the above but it would be something really similar I would imagine.

If you look at the Windows SDK header file um\gdiplusgraphics.h and at line 199 is the method SetTextRenderingHint

Status SetTextRenderingHint(IN TextRenderingHint newMode)
    {
        return SetStatus(DllExports::GdipSetTextRenderingHint(nativeGraphics,
                                                          newMode));
    }

and all the method is doing is calling the exported GdipSetTextRenderingHint function. So it is a matter of passing the native context to the exported function.

If you look at um\gdiplusflat.h at line 1615 you have the following code.

GpStatus WINGDIPAPI
GdipSetTextRenderingHint(GpGraphics *graphics, TextRenderingHint mode);

In you code example you are getting the handle of the native context and creating the GpGraphics instance in c code using that handle then calling the method which in turn calls the exported function. Since there is already an instance of the native context that can be gotten on the python side of things there should be a way to pass that native context to the exported function directly without having to compile a dll to do it for us,

[kdschlosser]

code correction.

TextRenderingHintAntiAliasGridFit = 3

def OnPaint(self, event):
    # Create paint DC
    dc = wx.PaintDC(self)

    # Create graphics context from it
    gc = wx.GraphicsContext.Create(dc)
    if gc:
        GdipSetTextRenderingHint(gc.GetNativeContext(), TextRenderingHintAntiAliasGridFit)

I think that should work. GetNativeContext returns a pointer to GpGraphics I believe.

[srirams]

Thanks! Didn't realize there was a wrapper api for gdiplus.

I can't seem to get the parameters right for the call however. GetNativeContext() gives a <class 'sip.voidptr'>

so this should work:
GdipSetTextRenderingHint(ctypes.c_void_p(gc.GetNativeContext().__int__()), TextRenderingHintAntiAliasGridFit)

however I'm getting a InvalidParameter result.

This:
GdipSetTextRenderingHint(gc.GetNativeContext(), TextRenderingHintAntiAliasGridFit)

results in:
[ctypes.ArgumentError: argument 1: <class 'TypeError'>: Don't know how to convert parameter 1]

[kdschlosser]

OK try wrapping the NativeContex in ctypes.byref()

[kdschlosser]

You can also try doing this

p = ctypes.c_void_p(gc.GetNativeContext().__int__())
 GdipSetTextRenderingHint(ctypes.byref(p), TextRenderingHintAntiAliasGridFit)

[kdschlosser]

I have another.

Here are 4 ways you can try it

p = gc.GetNativeContext()
 GdipSetTextRenderingHint(ctypes.byref(p), TextRenderingHintAntiAliasGridFit)

p = ctypes.c_void_p(gc.GetNativeContext().__int__())
 GdipSetTextRenderingHint(ctypes.byref(p), TextRenderingHintAntiAliasGridFit)

p = ctypes.cast(gc.GetNativeContext(), ctypes.POINTER(ctypes.c_void_p))
 GdipSetTextRenderingHint(p, TextRenderingHintAntiAliasGridFit)

p = ctypes.cast(gc.GetNativeContext(), ctypes.POINTER(ctypes.c_void_p))
 GdipSetTextRenderingHint(ctypes.byref(p), TextRenderingHintAntiAliasGridFit)

[srirams]

No, it doesn't work...

GdipSetTextRenderingHint expects a Gdiplus::GpGraphics* and what we have is Gdiplus::Graphics*, and I'm not sure how to convert between the two

[kdschlosser]

not sure then.