File Coverage

blib/lib/Device/PaPiRus.pm

Criterion	Covered	Total	%
statement	27	29	93.1
branch			n/a
condition			n/a
subroutine	10	10	100.0
pod			n/a
total	37	39	94.8

package Device::PaPiRus;
#---AUTOPRAGMASTART---
use 5.012;
use strict;
use warnings;
use diagnostics;
use mro 'c3';
use English qw( -no_match_vars );
use Carp;
our $VERSION = 1.1;
no if $] >= 5.017011, warnings => 'experimental::smartmatch';
use Fatal qw( close );
#---AUTOPRAGMAEND---

use GD;

sub new {
    my ($proto, %config) = @_;
    my $class = ref($proto) || $proto;

    my $self = {};

    bless $self, $class; # bless with our class

    # Let's load the display size
    open(my $ifh, '<', '/dev/epd/panel') or croak($OS_ERROR);
    my $line = <$ifh>;
    close $ifh;
    if($line =~ /\ (\d+)x(\d+)\ /) {
        ($self->{width}, $self->{height}) = ($1, $2);
    } else {
        croak("Can't read panel dimensions!");
    }

    # Default
    $self->{threshold} = 150;
    $self->{randomize_white} = 0;
    $self->{randomize_black} = 0;
    $self->{dithering} = 0;

    return $self;
}

sub getWidth {
    my ($self) = @_;

    return $self->{width};
}

sub getHeight {
    my ($self) = @_;

    return $self->{height};
}

sub randomizeWhite {
    my ($self, $val) = @_;

    $self->{randomize_white} = $val;
    return;
}

sub randomizeBlack {
    my ($self, $val) = @_;

    $self->{randomize_black} = $val;
    return;
}

sub useDithering {
    my ($self, $val) = @_;

    $self->{dithering} = $val;
    return;
}

sub setThreshold {
    my ($self, $threshold) = @_;

    $threshold = 0 + $threshold;
    if($threshold < 0) {
        croak("Threshold can not be less than zero");
    } elsif($threshold > 255) {
        croak("Threshold can not be larger than 255");
    }
    $self->{threshold} = $threshold;
    return;
}

sub fullUpdate {
    my ($self, $img) = @_;

    my $panelImage;
    if(!$self->{dithering}) {
        $panelImage = $self->calculateImage($img);
    } else {
        $panelImage = $self->calculateDitheringImage($img);
    }
    return $self->writeImage($panelImage, 'U');
}

sub partialUpdate {
    my ($self, $img) = @_;

    my $panelImage;
    if(!$self->{dithering}) {
        $panelImage = $self->calculateImage($img);
    } else {
        $panelImage = $self->calculateDitheringImage($img);
    }
    return $self->writeImage($panelImage, 'P');
}

sub writeImage {
    my ($self, $img, $mode) = @_;

    open(my $ofh, '>', '/dev/epd/display') or croak($!);
    binmode $ofh;
    print $ofh $img;
    close $ofh;

    open(my $cfh, '>', '/dev/epd/command') or croak($!);
    print $cfh $mode;
    close $cfh;

    return;
}

sub calculateImage {
    my ($self, $img) = @_;
    my $outimg = '';

    my ($sourcewidth, $sourceheight) = $img->getBounds();
    if($sourcewidth != $self->{width} || $sourceheight != $self->{height}) {
        croak('Image dimensions (' . $sourcewidth . 'x' . $sourceheight . ') do not match panel size (' . $self->{width} . 'x' . $self->{height} . ')!');
    }

    # We need to read 8 pixels of the image in one go, turn them into pure black&white bits and stuff the 8 of them into a single byte,
    # correcting for endianess and all that...
    for(my $y = 0; $y < $self->{height}; $y++) {
        for(my $x = 0; $x < ($self->{width} / 8); $x++) {
            my $buf = '';
            for(my $offs = 0; $offs < 8; $offs++) {
                my $index = $img->getPixel(($x*8) + $offs,$y);
                my ($r,$g,$b) = $img->rgb($index);
                my $grey = int(($r+$g+$b)/3);
                if($grey > $self->{threshold}) {
                    if($self->{randomize_white} && int(rand(10000)) % 4 == 0) {
                        $buf .= "1";
                    } else {
                        $buf .= "0";
                    }
                } else {
                    if($self->{randomize_black} && int(rand(10000)) % 4 == 0) {
                        $buf .= "0";
                    } else {
                        $buf .= "1";
                    }
                }
            }
            my $byte = pack('b8', $buf);
            $outimg .= $byte;
        }
    }

    return $outimg;
}

sub calculateDitheringImage {
    my ($self, $img) = @_;
    my $outimg = '';

    my ($sourcewidth, $sourceheight) = $img->getBounds();
    if($sourcewidth != $self->{width} || $sourceheight != $self->{height}) {
        croak('Image dimensions (' . $sourcewidth . 'x' . $sourceheight . ') do not match panel size (' . $self->{width} . 'x' . $self->{height} . ')!');
    }

    # Init array with the greyscale pixel value of the image
    my @npixel;
    for(my $x = 0; $x < $self->{width}; $x++) {
        my @nline;
        for(my $y = 0; $y < $self->{height}; $y++) {
            my $index = $img->getPixel($x, $y);
            my ($r,$g,$b) = $img->rgb($index);
            my $oldpixel = int(($r+$g+$b)/3);
            my $newpixel = $oldpixel / 255;
            push @nline, $newpixel;
        }
        $npixel[$x] = \@nline;
    }


    # Run dithering
    for(my $y = 0; $y < $self->{height}; $y++) {
        for(my $x = 0; $x < $self->{width}; $x++) {
            my $newpixel = $npixel[$x]->[$y];

            my $quant_error = (0.5 - $newpixel);

            # Correct neighboring pixels (if they exist)
            if(($x + 1) < $self->{width}) {
                $npixel[$x + 1]->[$y] = $npixel[$x + 1]->[$y] + ($quant_error * 7/16);
            }
            if($x > 0 && ($y + 1) < $self->{height}) {
                $npixel[$x - 1]->[$y + 1] = $npixel[$x - 1]->[$y + 1] + ($quant_error * 3/16);
            }
            if(($y + 1) < $self->{height}) {
                $npixel[$x]->[$y + 1] = $npixel[$x]->[$y + 1] + ($quant_error * 5/16);
            }
            if(($x + 1) < $self->{width} && ($y + 1) < $self->{height}) {
                $npixel[$x + 1]->[$y + 1] = $npixel[$x + 1]->[$y + 1] + ($quant_error * 1/16);
            }
        }
    }

    # We need to read 8 pixels of the image in one go, turn them into pure black&white bits and stuff the 8 of them into a single byte,
    # correcting for endianess and all that...
    for(my $y = 0; $y < $self->{height}; $y++) {
        for(my $x = 0; $x < ($self->{width} / 8); $x++) {
            my $buf = '';
            for(my $offs = 0; $offs < 8; $offs++) {
                my $raw = $npixel[($x * 8) + $offs]->[$y];
                if($raw >= 0.5) {
                    $buf .= '1';
                } else {
                    $buf .= '0';
                }
            }
            my $byte = pack('b8', $buf);
            $outimg .= $byte;
        }
    }

    return $outimg;
}


1;
__END__