ssp

I don't think that's true. Consider a simple case where the shape is a square and you are sampling in such a way that the closest edge point is closer to a corner of the square than the filter width. Using a function of distance you will get the same result as when sampling far from the corner. But the coverage is different in the two cases.

    localhost:~/oort/examples% ../oort callcc2.nl 
    2
    1

The Oort program:

    typedef continuation_t = fn (p: int32) -> void;
    
    call_cc (fun: fn(k: continuation_t) -> void) -> int32
    {
        retval: int32;
    
        fun (fn (v: int32) -> void {
            retval = v;
            goto current_continuation;
        });
        
        // If fun returns without calling the continuation,
        // then just return 0
        return 0;
    
    @current_continuation:
        return retval;
    }
    
    x: int32 = 0;
    
    print call_cc (fn (k: continuation_t) {
        x = 1;
        k (2);
        });
    
    print x;

A potentially interesting way around this is to make the client open source and get it shipped by all the Linux distributions. That would give application developers an initial audience which would help solve the chicken-and-egg problem.

GTK+ uses the triangle technique along with a delay of 225 ms. When the pointer is inside the triangle, the delay is 1500 ms.

Firefox subscribes to the misguided "fake the look and feel of the default toolkit" idea, so on Linux it has a 225 ms delay, but without the triangle. Unfortunately 225 ms is way too short when there is no triangle.

But in signal processing you interpret it as a two step procedure: First, for every mathematical point of the scene, compute the average light input of the surrounding square to produce a band limited signal. Second, for every pixel report the value at the corresponding point in the band limited image.

The first step is filtering (in this case with a box filter), the second is point sampling.

Someone takes a BSD project and bases a proprietary program on it. Is that person doing something wrong? Well, no, you say, because that's the whole point of the BSD license. It's also fine to keep rolling in new versions of the BSD project.

Now suppose someone takes a BSD project and relicenses it under the GPL, announces it on the internet, gets it into all the Linux distributions, and starts soliciting contributions of new GPL-only features while also rolling in new versions of the BSD project as they become available. Is that person doing something wrong?

I suspect that a calm, "No, that's also great. That's why we made it available under BSD." would not necessarily be the response.

http://www.asktog.com/papers/magic.html

It doesn't look like there any similar gold standard is emerging for phones.

Regarding this:

So a controlled amount of blur, and I'm not talking about anti-aliasing,

it's worth pointing out that anti-aliasing is a form of blur, but most software usually uses a box filter which is a really a poor filter. I have some demonstration images here:

http://www.freedesktop.org/~sandmann/tigers

Compare these two especially:

http://people.freedesktop.org/~sandmann/tigers/tiger-box.png

http://people.freedesktop.org/~sandmann/tigers/tiger-jinc-ga...

The first one is what cairo produces; the second is improved in three ways: (1) The antialiasing filter is based on the Jinc function rather than a box, (2) white and black are offset slightly from the top and bottom, and (3) the compositing is done in linear light, not sRGB.

The strokes in the second image are also somewhat wider in order to compensate for the lighter appearance that gamma-aware compositing produces.

That seems unlikely to me. Which processors do this?