para

#| loading and manipulation of PDF images
unit class PDF::Content::Image;
use PDF::COS;
use PDF::COS::Stream;
use PDF::IO;
use X::PDF::Content;



head

code

=begin code :lang<raku>
use PDF::Content::Image;
my PDF::Content::Image $image .= open: "t/images/lightbulb.gif";
say "image has size {$image.width} X {$image.height}";
say $image.data-uri;
# data:image/gif;base64,R0lGODlhEwATAMQA...
=end code


This class currently supports image formats: PNG, GIF and JPEG.



has Str $.data-uri;
subset IOish where PDF::IO|IO::Handle;
has IOish $.source;
subset ImageType of Str:D where 'JPEG'|'GIF'|'PNG'|'PDF';
subset DataURI   of Str:D where m/^('data:' [<ident> '/' <ident>]? ";base64"? ",")/;
has ImageType $.image-type;

method !image-type($_, :$path! --> ImageType) {
    when m:i/^ jpe?g $/    { 'JPEG' }
    when m:i/^ gif $/      { 'GIF' }
    when m:i/^ png $/      { 'PNG' }
    when m:i/^ pdf|json $/ { 'PDF' }
    default {
        die X::PDF::Content::Image::UnknownType.new( :$path );
    }
}

#| load an image from a data URI string
multi method load(DataURI $data-uri where m/^('data:' [<t=.ident> '/' <s=.ident>]? $<b64>=";base64"? $<start>=",") / --> ::?CLASS:D) {
    my $path = ~ $0;
    my Str $mime-type = ( $0<t> // '(missing)').lc;
    my Str $mime-subtype = ( $0<s> // '').lc;
    my Bool \base64 = ? $0<b64>;
    my Numeric \start = $0<start>.to;

    die X::PDF::Content::Image::UnknownMimeType.new: :$mime-type, :$path
        unless $mime-type eq 'image' || $mime-subtype eq 'pdf';
    my $image-type = self!image-type($mime-subtype, :$path);
    my $data = substr($data-uri, start);
    if base64 {
        use Base64::Native;
        $data = base64-decode($data).decode("latin-1");
    }

    my $source = PDF::IO.COERCE($data, :$path);
    self!image-handler(:$image-type).new: :$source, :$data-uri, :$image-type;
}

#| load an image from a path
multi method load(IO::Path() $iop --> ::?CLASS:D) is hidden-from-backtrace {
    my $ioh = $iop.open( :r, :bin);
    $ioh.fail if $ioh ~~ Failure;
    self.load: $ioh;
}

method !image-handler(Str :$image-type!) {
    PDF::COS.required("PDF::Content::Image::$image-type");
}

#| load an image from an IO handle
multi method load(IO::Handle $source! --> ::?CLASS:D) {
    my $path = $source.path;
    my Str $image-type = self!image-type($path.extension, :$path);
    self!image-handler(:$image-type).new: :$source, :$image-type;
}

# build a data uri from a binary source with a given image-type
sub make-data-uri(Str :$image-type!, :$source! --> Str) is export(:make-data-uri) {
    with $source {
        use Base64::Native;
        my Blob $bytes = .isa(Str)
            ?? .encode("latin-1")
            !! .path.IO.slurp(:bin);
        my $class = $image-type.lc eq 'pdf' ?? 'application' !! 'image';
        my $enc = base64-encode($bytes.decode("latin-1"), :str, :enc<latin-1>);
        'data:%s/%s;base64,%s'.sprintf($class, $image-type.lc, $enc);
    }
    else {
        fail 'image is not associated with a source';
    }
}

#| Get or set the data URI from an image
method data-uri returns DataURI is rw {
    Proxy.new(
        FETCH => {
            $!data-uri //= make-data-uri( :$.image-type, :$!source );
        },
        STORE => -> $, $!data-uri {},
    )
}

method open(|c) is DEPRECATED<PDF::Content::XObject.open> {
    PDF::COS.required('PDF::Content::XObject').open(|c);
}



root

Matrix

FontObj

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Image

Synopsis

Description

PDF::Content v0.9.11

Authors

License

Dependencies

Test Dependencies

Provides

Documentation