Ok, I've got a few friends who are epileptic and who I think would really enjoy algoraves except I daren't invite them because of the prevalence of flashing lights.

Visuals are live coded, so we can't just ask people not to make dramatic blinks, as live coding is inherently serendipitous, with unexpected results. Flashes are inevitable at the point of the HDMI output port.

However, I wonder if there might be additional options to increase accessibility. Our normal practice is to plug directly into a projector, but I think we could have an intermediate filter that detects the kind of value changes that are like to trigger a seizure and can fade them more slowly. Does something like this exist off the shelf?

Is there a way to add this kind of filter to web based languages so web pages can optionally operate in a safe mode?

I'm not saying "no strobes ever" but it would be extremely good of we could say "no strobes sometimes."

#algorave #livecode #accessibility

@celesteh reminded of something @hellocatfood told me about a piece he made for public display having to get OKed for not being an epilepsy trigger. There was some software that was doing the checking, but it was closed source, commercial, and/or not available to the public, so it wasn't clear what it was actually checking for 🤷‍♂️

@rumblesan @celesteh That'll be this thing https://www.hellocatfood.com/potentially-harmful/ (10 years old in two days!)

The software the broadcasters were using is closed source and analyses already rendered videos.

For something to work on a live feed there'd have to be a frame delay for it to analyse x incoming frames and then do _something_ to them, which isn't ideal for precise timing of visuals.

I think onus needs to be on the person making the visuals. In hydra there's a function to interpolate between values and the speed of this can be controlled. But it can't protect against flashes due to feedback loops.

@hellocatfood @rumblesan

The BBC uses some software for this which is incredibly expensive.

However, there exists a public formula for calculating contrast, normally used to check if a text and background are distant enough. That formula can probably be used to check contrast differences between adjacent frames.

I think that the delay can be mitigated by comparing to already output frames rather than looking ahead. So for time t (for every pixel?)
a = contrast(t, t-1);
If a <= y, then output t and save it to t-1.

Else t = t + ((t - 1) / a), then output t and save it to t-1

I think this would create a running average and do fading based on contrast, with fairly minimal delay, depending on frame rate.

Unfortunately, I don't know how to test it without access to the broadcast software because it's not like I can ask an epileptic person to rate the results....

A white square bouncing around a black screen is safe and doesn't need a fade trail, so this isn't really right, but its computationally cheap and would probably solve the problem. But if it doesn't we've wandered into a liability dilemma which is why nobody is going to release a floss version of this, nor make it available via a free API. Its expensive because mistakes are incredibly costly.

Before you continue