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.3;
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 = \%config;

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

    # Let's load the display size
    if(defined($self->{debug}) && $self->{debug}) {
        # Debugging only, no actual device
        $self->{width} = 264;
        $self->{height} = 176;
    } else {
        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;
    $self->{greyscale} = 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 useGreyscale {
    my ($self, $val) = @_;

    $self->{greyscale} = $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->calculateDitheringImage($img);
    } elsif($self->{greyscale}) {
        $panelImage = $self->calculateGreyscaleImage($img);
    } else {
        $panelImage = $self->calculateImage($img);
    }
    return $self->writeImage($panelImage, 'U');
}

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

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

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

    if(defined($self->{debug}) && $self->{debug}) {
        # Debugging only, no actual device
        return;
    }

    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 calculateGreyscaleImage {
    my ($self, $img) = @_;
    my $outimg = '';

    my ($stepsize, @greys);
    if($self->{greyscale} == 1) {
        $stepsize = 2;
        @greys = ('0000', '1000', '1010', '1110', '1111');
    } elsif($self->{greyscale} == 2) {
        $stepsize = 3;
        @greys = (
            '000000000',
            '000010000',
            '100000001',
            '010101000',
            '001010110',
            '101010101',
            '010101111',
            '011111110',
            '111101111',
            '111111111',
        );
    } elsif($self->{greyscale} == 3) {
        $stepsize = 4;
        @greys = (
            '0000000000000000',
            '0000000001000000',
            '0000100000100000',
            '0010000001000001',
            '1000001000101000',
            '1010000000010110',
            '0001010001101010',
            '1010110010100100',
            '1010010101101010',
            '1001011001011011',
            '1001011110101101',
            '1101101001111110',
            '1011111001111011',
            '1011011111101111',
            '1111011111101111',
            '1111111110111111',
            '1111111111111111',
        );
    } else {
        croak("Greyscale mode " . $self->{greyscale} . " not implemented!");
    }

    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 @opixel;
    my @npixel;
    for(my $x = 0; $x < $self->{width}; $x++) {
        my @oline;
        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);
            push @oline, $oldpixel;
            push @nline, 0;
        }
        $opixel[$x] = \@oline;
        $npixel[$x] = \@nline;
    }


    # Run greyscale
    for(my $y = 0; $y < $self->{height} - ($stepsize - 1); $y+= $stepsize) {
        for(my $x = 0; $x < $self->{width} - ($stepsize - 1); $x+= $stepsize) {
            my $oldpixel = 0;
            for(my $ox = 0; $ox < $stepsize; $ox++) {
                for(my $oy = 0; $oy < $stepsize; $oy++) {
                    $oldpixel += $opixel[$x + $ox]->[$y + $oy];
                }
            }
            $oldpixel = $oldpixel / ($stepsize * $stepsize); # Average

            my $offs = int($oldpixel / (256 / (($stepsize * $stepsize) + 1)));
            my @greypixel = split//, $greys[$offs];

            for(my $ox = 0; $ox < $stepsize; $ox++) {
                for(my $oy = 0; $oy < $stepsize; $oy++) {
                    $npixel[$x + $ox]->[$y + $oy] = $greypixel[($ox * $stepsize) + $oy];
                }
            }
        }
    }

    # 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 .= '0';
                } else {
                    $buf .= '1';
                }
            }
            my $byte = pack('b8', $buf);
            $outimg .= $byte;
        }
    }

    return $outimg;
}

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

    my ($stepsize, @greys);
    if($self->{dithering} == 1) {
        $stepsize = 2;
        @greys = ('0000', '1000', '1010', '1110', '1111');
    } elsif($self->{dithering} == 2) {
        $stepsize = 3;
        @greys = (
            '000000000',
            '000010000',
            '100000001',
            '010101000',
            '001010110',
            '101010101',
            '010101111',
            '011111110',
            '111101111',
            '111111111',
        );
    } elsif($self->{dithering} == 3) {
        $stepsize = 4;
        @greys = (
            '0000000000000000',
            '0000000001000000',
            '0000100000100000',
            '0010000001000001',
            '1000001000101000',
            '1010000000010110',
            '0001010001101010',
            '1010110010100100',
            '1010010101101010',
            '1001011001011011',
            '1001011110101101',
            '1101101001111110',
            '1011111001111011',
            '1011011111101111',
            '1111011111101111',
            '1111111110111111',
            '1111111111111111',
        );
    } else {
        croak("Greyscale mode " . $self->{greyscale} . " not implemented!");
    }

    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 @opixel;
    my @npixel;
    for(my $x = 0; $x < $self->{width}; $x++) {
        my @oline;
        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);
            push @oline, $oldpixel;
            my @tmp;
            push @nline, \@tmp;
        }
        $opixel[$x] = \@oline;
        $npixel[$x] = \@nline;
    }


    # Run greyscale FOR EACH PIXEL
    for(my $y = 0; $y < $self->{height}; $y++) {
        for(my $x = 0; $x < $self->{width}; $x++) {
            my $oldpixel = 0;
            my $count = 0;
            for(my $ox = 0; $ox < $stepsize; $ox++) {
                for(my $oy = 0; $oy < $stepsize; $oy++) {
                    if(($x + $ox) < $self->{width} && ($y + $oy) < $self->{height}) {
                        $oldpixel += $opixel[$x + $ox]->[$y + $oy];
                        $count++
                    }
                }
            }
            next unless $count;
            $oldpixel = $oldpixel / $count; # Average

            my $offs = int($oldpixel / (256 / (($stepsize * $stepsize) + 1)));
            my @greypixel = split//, $greys[$offs];

            for(my $ox = 0; $ox < $stepsize; $ox++) {
                for(my $oy = 0; $oy < $stepsize; $oy++) {
                    push @{$npixel[$x + $ox]->[$y + $oy]}, $greypixel[($ox * $stepsize) + $oy];
                }
            }
        }
    }

    #print Dumper (\@npixel);
    #die;

    # 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...
    # We have multiple b&w values for each pixel. We need to add them up and decide if it really is B or W
    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];

                my @vals = @{$npixel[($x * 8) + $offs]->[$y]};
                my $raw = 0;
                foreach my $val (@vals) {
                    $raw += $val;
                }
                if(scalar @vals) {
                    $raw = $raw / (scalar @vals);
                }

                if($raw >= 0.5) {
                    $buf .= '0';
                } else {
                    $buf .= '1';
                }
            }
            my $byte = pack('b8', $buf);
            $outimg .= $byte;
        }
    }

    return $outimg;
}

1;
__END__