Preventing TV / Monitor burn in, in a WPF program [closed]

Question

I've recently finished a WPF program for a client that will be on burn-in prone TVs at least 12 (Maybe even 16+) hours a day. Problem is, the data is near static (Some text changes every few hours, but for the most part it's static). Another issue is that the design is very specific and needs to stay that way - so I can't move the elements around randomly. I also can't do anything dramatic like have something bouncing around the screen as the screens will show important information.

So, I'm struggling to find a way to prevent burn in. What's a good way to prevent this? Preferably in WPF. The client and I have come up with the possible solution of having an AHK script trigger the screen saver every hour, but that seems really hacky.

Westfall

Asking for a library is not a good way to phrase the question as that is off topic for SO. But strategies for hiding text or switching up the screen would make for an interesting answer. – Spectacles

You need to work with the client and explain the issue, something has to give. The only way to prevent burn in is to change the screen (which is why screen savers exist, originally). – Playboy

Set a timer and display a black screen for a second or two every few minutes maybe? Or switch the display for the company logo instead of black screen. – Snaggletooth

Updated the question, and not an awful idea Rodrigo - if all else fails I'll do that, however that may interrupt workflow for the client so it's not ideal. – Westfall

Can you share a screenshot? If your program is mostly white for example, that is entirely a different matter than a black one. – Pebbly

We had the same problem in our call center and the solution was to purchase TVs with burn-in proof displays... – Councilwoman

Sadly I can not share a screenshot, however I can paint a (Mental) picture. 3 big red boxes, 3 big blue boxes, 2 green boxes all on a black background - white, red, and yellow text in each box. And Dean K, that sounds like an... Interesting solution – Westfall

And are these colours set in stone? Could you alternate the colours between each of the boxes? (so all the red ones become blue every 30 minutes?) – Pebbly

That may be an option, Troels - however how would you accomplish this in WPF? That's my main issue here. I can think of a few methods that may work, but actually making them work in WPF is something else entirely. – Westfall

It's too bad that burn in prone TVs were chosen for static imagery. What are the chances of replacing those with something more in line with the business need? It seems like a "trying to make a pen work in space instead of using a pencil" type of problem. – Junkojunkyard

@Junkojunkyard - I may have to consider that, however the client was very specific in the design. If it were something I made, yeah - burn in would be something I designed around, but it was a graphic designer who contracted me to make it so... Plus I'm just plain interested in seeing solutions, it's an issue I've never had to deal with before. – Westfall

Answer 1

Why not just build a storyboard in blend that slowly, over the course of say 30 minutes, changes the color scheme to something else that doesn't clash then changes it back again?

Tarpon

Answer 2

Could you use something like a vertical "Refresh Bar" that sweep across the screen periodically, drawn in exclusive-or mode over the status text and boxes?

By a "XOR mode refersh bar" I mean something like this, that crawls across the screen every few minutes in the direction of the arrow shown:

Cuirass

I was thinking along these lines, but rather than a refresh bar, have the name of the company stretched to vertically fill the screen, could look a bit slicker – Dayak

I'm fairly new to WPF, so I'm not sure if this is possible. I'd be interested in hearing from people with WPF experience comment on this though. – Westfall

@Westfall I'm pretty confident this would be possible, could probably be done with WPF pixel shaders – Dayak

Nice idea, that would make sure all the pixels change and its not too intrusive. He could probably make it a pixel or two wide so it is not as noticeable and span it out to once every 30 minutes/hour or so. I'll keep this one in the back of my head incase I ever have the need. – Relent

Answer 3

Doing a quick google search I found this and it may be useful.

CRTs and Older plasma TVs were quite susceptible to burn-in, but many modern TVs have features designed to lower the risk. Many contain a feature called "pixel shifting," for example, that shifts the image on your screen just enough so that the pixels are regularly changing, (but not so much that it's noticeable to you). Some cheaper plasmas may be more susceptible, so this is an area where you get what you pay for.

With that said, perhaps you can emulate the same effect with your program. You could shift the whole view a few pixels left or right and through out the day have them shift back. Could be easier than said as I have no actual WPF experience but I thought this was a neat idea.

Reference: http://lifehacker.com/5982108/is-burn-in-still-an-issue-on-tvs-and-monitors

Relent

I had thought of that, but the design is simple and only contains a few colors (And large blocks of the same color), so it'd have to be more than just pixel shifting. I guess I may be able to have random colored pixels (A few at a time) go over the entire screen over the course of a few minutes? Would that be enough? – Westfall

I do not know enough about "burn-in" but maybe you can ask your client for an acceptable color range as far as brighter and darker and then through out the day increase and decrease the brightness of the color. Then you have the same "base feel" but have the colors changing. I am not sure personally how dramatic the color changes would have to be to be effective though. – Relent

Answer 4

New answer for a new approach. This is much simpler, and has animation:

<Grid x:Name="MyGrid">
    <Grid.Background>
        <SolidColorBrush x:Name="bg" Color="Red"/>
    </Grid.Background>
    <Grid.Triggers>
        <EventTrigger RoutedEvent="Window.Loaded">
            <BeginStoryboard>
                <Storyboard RepeatBehavior="Forever">
                    <ColorAnimation Storyboard.TargetName="bg"
                                    Storyboard.TargetProperty="Color" 
                                    From="Red" To="Blue" 
                                    Duration="0:0:10" BeginTime="0:0:0"/>
                    <ColorAnimation Storyboard.TargetName="bg"
                                    Storyboard.TargetProperty="Color" 
                                    From="Blue" To="Red" 
                                    Duration="0:0:10" BeginTime="0:0:10"/>
                </Storyboard>
            </BeginStoryboard>
        </EventTrigger>
    </Grid.Triggers>
</Grid>

Set the duration to 30 minutes. Naturally, this will cause the colour to be purple at times. I didn't think that was acceptable to your client, which is why I didn't suggest it initially.

If this is not acceptable, an option would be to fade the controls out before switching colours. (Add two more double animations for Opacity to the storyboard).

Pebbly

Answer 5

Here is an example that toggles the colour of the Grid every second using a DispatcherTimer:

public partial class MainWindow : Window, INotifyPropertyChanged
{
    private bool _isMainColour;

    public SolidColorBrush CurrentColour { get; set; }

    private DispatcherTimer _timer;

    public MainWindow()
    {
        InitializeComponent();
        DataContext = this;
        _timer = new DispatcherTimer();
        _timer.Interval = new TimeSpan(0, 0, 1);
        _timer.Tick += _timer_Tick;
        _timer.Start();
    }

    void _timer_Tick(object sender, EventArgs e)
    {
        if (_isMainColour)
        {
            CurrentColour = new SolidColorBrush(Colors.Blue);
        }
        else
        {
            CurrentColour = new SolidColorBrush(Colors.Red);
        }
        _isMainColour = !_isMainColour;
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs("CurrentColour"));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

And the XAML:

<Window x:Class="WpfApplication4.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525" Background="Black">
    <Grid Background="{Binding CurrentColour}">

    </Grid>
</Window>

Obviously, it needs better structuring, but it shows the basic principle.

Pebbly

Toggling the colour of the grid every (few) seconds will not be aesthetically pleasing, nor very user-friendly. – Samp

This code helps a lot, if the other solutions don't work and the client will accept this as a solution, I'll definitely use your code. However rather than an abrupt change, I'd make it gradual and alternate between colors. – Westfall

@CodeCaster: I put 1 second in there so OP wouldn't have to wait 30 minutes for the change... I assume OP is able to change the 1s to something larger :D – Pebbly

Answer 6

I would say binding the colours to resources using DyanmicResource binding is a good start.

You can then implement a timer in your app.cs that when triggered updates the values:

this.Resource["PrimaryColour"] = Color.FromRgb(200, 200, 200);

Heaton