C++ and Qt: Paint Program - Rendering Transparent Lines Without Alpha Joint Overlap

Question

I have started to create a paint program that interacts with drawing tablets. Depending on the pressure of the pen on the tablet I change the alpha value of the line being drawn. That mechanism works.

Thin lines look decent and it looks a real sketch. But since I am drawing lines between two points (like in the Qt scribble tutorial) to paint there is an alpha overlap between the line joints and it is very noticeable for thick strokes.

This is the effect with line to line conjuction:

As you can see, there is an ugly alpha blend between the line segments.

In order to solve this I decided to use a QPainterPath to render lines. Two problems with this:

1. A long, continuous, thick path quickly lags the program.
2. Since the path is connected it acts as one, so any change to the alpha value affects the the entire path(which I don't want since I want to preserve a blending effect).

The following images use a QPainterPath.

The blend effect I want to keep.

The following image shows the 2nd problem which changes the alpha and thickness of the entire path

The red text should read: "if more pressure is added without removing the pen from the tablet surface the line thickens" (and alpha becomes opaque)

Another thing is that with this approach I can only get a blending trail from a dark to light (or thick to thin path width) but not light to dark. I am not sure why this effect occurs but my best guess is that it has to do with the line segments of the path updating as whole.

I did make the program increase/decrease alpha and line thickness based on the pressure of the pen on the tablet.

The problem is that I want to render lines without the alpha overlap and QPainterPath updates the entire path's alpha and thickness which I don't want.

This is the code that creates the path:

    switch(event->type()){
    case QEvent::TabletPress:
        if(!onTablet){
            onTablet = true;

            //empty for new segment
            freePainterPath();
            path = new QPainterPath(event->pos());
        }   break;

    case QEvent::TabletRelease:
        if(onTablet)
            onTablet = false;
            break;

    case QEvent::TabletMove:
        if(path != NULL)
            path->lineTo(event->pos());

        if(onTablet){

            //checks for pressure of pen on tablet to change alpha/line thickness
            brushEffect(event);

            QPainter painter(&pixmap);

            //renders the path
            paintPixmap(painter, event);
        }   break;
    default:;
}
update();

The desired effect that I want as a single path (image created with Krita paint program):

Answer 1

I know this question is very old, and has an accepted answer, but in case someone else needs the answer, here it is:

You need to set the composition mode of painter to source. It draws both source and destination right now.

painter.setCompositionMode(QPainter::CompositionMode_Source);

If you want your transparent areas to show through underlying drawings, you need to set the composition mode of your result back to CompositionMode_SourceOver and draw over destination.

I don't know if you still look for an answer, but I hope this helps someone.

Answer 2

To emulate the Krita paint program:

1. Keep a backup of the original target surface.
2. Paint with your brush onto a scratch surface that starts out completely transparent.
3. On that surface, your composting rule is "take maximum opacity".
4. Keep track of the dirty regions of that surface, and do a traditional composite of (scratch surface) onto (original target surface) and display the result. Make sure this operation doesn't damage the original target surface.

Now, you don't have to keep the entire original target surface -- just the parts you have drawn on with this tool. (A good tile based lazy-write imaging system will make this easy).

Depending on the segment size you are drawing with, you may want to interpolate between segments to make the strength of the brush be a bit less sharp. The shape of your brush may also need work. But these are independent of the transparency problem.

As for the Qt strangeness, I don't know enough Qt to tell you how to deal with the quirks of Qt's brush code. But the above "key-mask" strategy should solve your alpha overlap problem.

I do not know how to do this in Qt. Glancing at the Qt compositing modes I don't see an obvious way to say "take maximum" as the resulting alpha. Maybe something involving both color and alpha channels in some clever way.