origamindee 3.0.0

data/lib/origami/graphics/colors.rb

@@ -0,0 +1,230 @@
+=begin
+
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module Origami
+
+    module Graphics
+
+        class InvalidColorError < Error #:nodoc:
+        end
+
+        module Color
+
+            module Intent
+                ABSOLUTE = :AbsoluteColorimetric
+                RELATIVE = :RelativeColorimetric
+                SATURATION = :Saturation
+                PERCEPTUAL = :Perceptual
+            end
+
+            module BlendMode
+                NORMAL      = :Normal
+                COMPATIBLE  = :Compatible
+                MULTIPLY    = :Multiply
+                SCREEN      = :Screen
+                OVERLAY     = :Overlay
+                DARKEN      = :Darken
+                LIGHTEN     = :Lighten
+                COLORDODGE  = :ColorDodge
+                COLORBURN   = :ColorBurn
+                HARDLIGHT   = :HardLight
+                SOFTLIGHt   = :SoftLight
+                DIFFERENCE  = :Difference
+                EXCLUSION   = :Exclusion
+            end
+
+            module Space
+                DEVICE_GRAY   = :DeviceGray
+                DEVICE_RGB    = :DeviceRGB
+                DEVICE_CMYK   = :DeviceCMYK
+            end
+
+            def self.cmyk_to_rgb(c, m, y, k)
+                r = 1 - (( c * ( 1 - k ) + k ))
+                g = 1 - (( m * ( 1 - k ) + k ))
+                b = 1 - (( y * ( 1 - k ) + k ))
+
+                [ r, g, b ]
+            end
+
+            def self.gray_to_rgb(g)
+                [ g, g, g ]
+            end
+
+            #
+            # Class representing an embedded ICC Profile stream.
+            #
+            class ICCProfile < Stream
+                field :N,           :Type => Integer, :Required => true, :Version => '1.3'
+                field :Alternate,   :Type => [ Name, Array ]
+                field :Range,       :Type => Array
+                field :Metadata,    :Type => Stream, :Version => '1.4'
+            end
+
+            class GrayScale
+                attr_accessor :g
+
+                def initialize(g)
+                    @g = g
+                end
+            end
+
+            class RGB
+                attr_accessor :r,:g,:b
+
+                def initialize(r,g,b)
+                    @r,@g,@b = r,g,b
+                end
+            end
+
+            class CMYK
+                attr_accessor :c,:m,:y,:k
+
+                def initialize(c,m,y,k)
+                    @c,@m,@y,@k = c,m,y,k
+                end
+            end
+
+            def Color.to_a(color)
+                return color if color.is_a?(::Array)
+
+                if %i(r g b).all? {|c| color.respond_to?(c)}
+                    r = color.r.to_f / 255
+                    g = color.g.to_f / 255
+                    b = color.b.to_f / 255
+                    return [r, g, b]
+
+                elsif %i(c m y k).all? {|c| color.respond_to?(c)}
+                    c = color.c
+                    m = color.m
+                    y = color.y
+                    k = color.k
+                    return [c,m,y,k]
+
+                elsif color.respond_to?(:g)
+                    g = color.g
+                    return [g]
+
+                else
+                    raise TypeError, "Invalid color : #{color}"
+                end
+            end
+        end
+
+        class State
+            def set_stroking_color(color, space = @stroking_color_space)
+                check_color(space, color) 
+
+                @stroking_colorspace = space
+                @stroking_color = color
+            end
+
+            def set_nonstroking_color(color, space = @nonstroking_colorspace)
+                check_color(space, color)
+
+                @nonstroking_colorspace = space
+                @nonstroking_color = color
+            end
+
+            def set_stroking_colorspace(space)
+                check_color_space(space, @stroking_color)
+
+                @stroking_color_space = space
+            end
+
+            def set_nonstroking_colorspace(space)
+                check_color_space(space, @nonstroking_color)
+
+                @nonstroking_color_space = space
+            end
+
+            private
+
+            def check_color_space(space)
+                case space
+                when Color::Space::DEVICE_GRAY, Color::Space::DEVICE_RGB, Color::Space::DEVICE_CMYK
+                else
+                   raise InvalidColorError, "Unknown color space #{space}"
+                end 
+            end
+
+            def check_color(space, color)
+                valid_color =
+                    case space
+                    when Color::Space::DEVICE_GRAY
+                        check_gray_color(color)
+                    when Color::Space::DEVICE_RGB
+                        check_rgb_color(color)
+                    when Color::Space::DEVICE_CMYK
+                        check_cmyk_color(color)
+                    else
+                        raise InvalidColorError, "Unknown color space #{space}"
+                    end
+
+                raise InvalidColorError, "Invalid color #{color.inspect} for #{space}" unless valid_color
+            end
+
+            def check_gray_color(color)
+                color.is_a?(::Array) and color.length == 1 and (0..1).include?(color[0])
+            end
+
+            def check_rgb_color(color)
+                color.is_a?(::Array) and color.length == 3 and color.all? {|c| (0..1).include?(c) }
+            end
+
+            def check_cmyk_color(color)
+                color.is_a?(::Array) and color.length == 4 and color.all? {|c| (0..1).include?(c) }
+            end
+        end
+    end
+
+    class PDF::Instruction
+
+        insn 'CS', Name do |canvas, cs| canvas.gs.set_stroking_colorspace(cs) end
+        insn 'cs', Name do |canvas, cs| canvas.gs.set_nonstroking_colorspace(cs) end
+        insn 'SC', '*' do |canvas, *c| canvas.gs.set_stroking_color(c) end
+        insn 'sc', '*' do |canvas, *c| canvas.gs.set_nonstroking_color(c) end
+
+        insn 'G', Real do |canvas, c|
+            canvas.gs.set_stroking_color([c], Graphics::Color::Space::DEVICE_GRAY)
+        end
+
+        insn 'g', Real do |canvas, c|
+            canvas.gs.set_nonstroking_color([c], Graphics::Color::Space::DEVICE_GRAY)
+        end
+
+        insn 'RG', Real, Real, Real do |canvas, r, g, b|
+            canvas.gs.set_stroking_color([r, g, b], Graphics::Color::Space::DEVICE_RGB)
+        end
+
+        insn 'rg', Real, Real, Real do |canvas, r, g, b|
+            canvas.gs.set_nonstroking_color([r, g, b], Graphics::Color::Space::DEVICE_RGB)
+        end
+
+        insn 'K', Real, Real, Real, Real do |canvas, c, m, y, k|
+            canvas.gs.set_stroking_color([c, m, y, k], Graphics::Color::Space::DEVICE_CMYK)
+        end
+
+        insn 'k', Real, Real, Real, Real do |canvas, c, m, y, k|
+            canvas.gs.set_nonstroking_color([c, m, y, k], Graphics::Color::Space::DEVICE_CMYK)
+        end
+    end
+
+end

data/lib/origami/graphics/instruction.rb

@@ -0,0 +1,98 @@
+=begin
+
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module Origami
+
+    class InvalidPDFInstructionError < Error; end
+
+    class PDF::Instruction
+        using TypeConversion
+
+        attr_reader :operator
+        attr_accessor :operands
+
+        @insns = Hash.new(operands: [], render: lambda{})
+
+        def initialize(operator, *operands)
+            @operator = operator
+            @operands = operands.map!{|arg| arg.is_a?(Origami::Object) ? arg.value : arg}
+
+            if self.class.has_op?(operator)
+                opdef = self.class.get_operands(operator)
+
+                if not opdef.include?('*') and opdef.size != operands.size
+                    raise InvalidPDFInstructionError,
+                            "Numbers of operands mismatch for #{operator}: #{operands.inspect}"
+                end
+            end
+        end
+
+        def render(canvas)
+            self.class.get_render_proc(@operator)[canvas, *@operands]
+
+            self
+        end
+
+        def to_s
+            "#{operands.map{|op| op.to_o.to_s}.join(' ')}#{' ' unless operands.empty?}#{operator}\n"
+        end
+
+        class << self
+            def insn(operator, *operands, &render_proc)
+                @insns[operator] = {}
+                @insns[operator][:operands] = operands
+                @insns[operator][:render] = render_proc || lambda{}
+            end
+
+            def has_op?(operator)
+                @insns.has_key? operator
+            end
+
+            def get_render_proc(operator)
+                @insns[operator][:render]
+            end
+
+            def get_operands(operator)
+                @insns[operator][:operands]
+            end
+
+            def parse(stream)
+                operands = []
+                while type = Object.typeof(stream, true)
+                    operands.push type.parse(stream)
+                end
+
+                if not stream.eos?
+                    if stream.scan(/(?<operator>[[:graph:]&&[^\[\]<>()%\/]]+)/).nil?
+                        raise InvalidPDFInstructionError, "Operator: #{(stream.peek(10) + '...').inspect}"
+                    end
+
+                    operator = stream['operator']
+                    PDF::Instruction.new(operator, *operands)
+                else
+                    unless operands.empty?
+                        raise InvalidPDFInstructionError, "No operator given for operands: #{operands.map(&:to_s).join(' ')}"
+                    end
+                end
+            end
+        end
+
+    end
+end

data/lib/origami/graphics/path.rb

@@ -0,0 +1,182 @@
+=begin
+
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module Origami
+
+    module Graphics
+
+        module LineCapStyle
+            BUTT_CAP              = 0
+            ROUND_CAP             = 1
+            PROJECTING_SQUARE_CAP = 2
+        end
+
+        module LineJoinStyle
+            MITER_JOIN = 0
+            ROUND_JOIN = 1
+            BEVEL_JOIN = 2
+        end
+
+        class DashPattern
+            attr_accessor :array, :phase
+
+            def initialize(array, phase = 0)
+                @array = array
+                @phase = phase
+            end
+
+            def eql?(dash) #:nodoc
+                dash.array == @array and dash.phase == @phase
+            end
+
+            def hash #:nodoc:
+                [ @array, @phase ].hash
+            end
+        end
+
+        class InvalidPathError < Error #:nodoc:
+        end
+
+        class Path
+            module Segment
+                attr_accessor :from, :to
+
+                def initialize(from, to)
+                    @from, @to = from, to
+                end
+            end
+
+            class Line
+                include Segment
+            end
+
+            attr_accessor :current_point
+            attr_reader :segments
+
+            def initialize
+                @segments = []
+                @current_point = nil
+                @closed = false
+            end
+
+            def is_closed?
+                @closed
+            end
+
+            def close!
+                from = @current_point
+                to = @segments.first.from
+
+                @segments << Line.new(from, to)
+                @segments.freeze
+                @closed = true
+            end
+
+            def add_segment(seg)
+                raise GraphicsStateError, "Cannot modify closed subpath" if is_closed?
+
+                @segments << seg
+                @current_point = seg.to
+            end
+        end
+    end
+
+    class PDF::Instruction
+        insn 'm', Real, Real do |canvas, x,y|
+            canvas.gs.current_path << (subpath = Graphics::Path.new)
+            subpath.current_point = [x,y]
+        end
+
+        insn 'l', Real, Real do |canvas, x,y|
+            if canvas.gs.current_path.empty?
+                raise InvalidPathError, "No current point is defined"
+            end
+
+            subpath = canvas.gs.current_path.last
+
+            from = subpath.current_point
+            to = [x,y]
+            subpath.add_segment(Graphics::Path::Line.new(from, to))
+        end
+
+        insn 'h' do |canvas|
+            unless canvas.gs.current_path.empty?
+                subpath = canvas.gs.current_path.last
+                subpath.close! unless subpath.is_closed?
+            end
+        end
+
+        insn 're', Real, Real, Real, Real do |canvas, x,y,width,height|
+            tx = x + width
+            ty = y + height
+            canvas.gs.current_path << (subpath = Graphics::Path.new)
+            subpath.segments << Graphics::Path::Line.new([x,y], [tx,y])
+            subpath.segments << Graphics::Path::Line.new([tx,y], [tx, ty])
+            subpath.segments << Graphics::Path::Line.new([tx, ty], [x, ty])
+            subpath.close!
+        end
+
+        insn 'S' do |canvas|
+            canvas.stroke_path
+        end
+
+        insn 's' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.stroke_path
+        end
+
+        insn 'f' do |canvas|
+            canvas.fill_path
+        end
+
+        insn 'F' do |canvas|
+            canvas.fill_path
+        end
+
+        insn 'f*' do |canvas|
+            canvas.fill_path
+        end
+
+        insn 'B' do |canvas|
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn 'B*' do |canvas|
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn 'b' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn 'b*' do |canvas|
+            canvas.gs.current_path.last.close!
+            canvas.fill_path
+            canvas.stroke_path
+        end
+
+        insn 'n'
+    end
+
+end

data/lib/origami/graphics/patterns.rb

@@ -0,0 +1,174 @@
+=begin
+
+    This file is part of Origami, PDF manipulation framework for Ruby
+    Copyright (C) 2016	Guillaume Delugré.
+
+    Origami is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Origami is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with Origami.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module Origami
+
+    module Graphics
+
+        module Pattern
+            module Type
+                TILING  = 1
+                SHADING = 2
+            end
+
+            def self.included(receiver)
+                receiver.field  :Type,          :Type => Name, :Default => :Pattern
+                receiver.field  :PatternType,   :Type => Integer, :Required => true
+            end
+
+            class Tiling < ContentStream
+                include Pattern
+                include ResourcesHolder
+
+                module PaintType
+                    COLOURED    = 1
+                    UNCOLOURED  = 2
+                end
+
+                module Type
+                    CONSTANT_SPACING                    = 1
+                    NO_DISTORTION                       = 2
+                    CONSTANT_SPACING_AND_FASTER_TILING  = 3
+                end
+
+                field   :PatternType,           :Type => Integer, :Default => Pattern::Type::TILING, :Required => true
+                field   :PaintType,             :Type => Integer, :Required => true
+                field   :TilingType,            :Type => Integer, :Required => true
+                field   :BBox,                  :Type => Rectangle, :Required => true
+                field   :XStep,                 :Type => Number, :Required => true
+                field   :YStep,                 :Type => Number, :Required => true
+                field   :Resources,             :Type => Resources, :Required => true
+                field   :Matrix,                :Type => Array.of(Number, length: 6), :Default => [ 1, 0, 0, 1, 0, 0 ]
+            end
+
+            class Shading < Dictionary
+                include StandardObject
+                include Pattern
+
+                module Type
+                    FUNCTION_BASED              = 1
+                    AXIAL                       = 2
+                    RADIAL                      = 3
+                    FREEFORM_TRIANGLE_MESH      = 4
+                    LATTICEFORM_TRIANGLE_MESH   = 5
+                    COONS_PATCH_MESH            = 6
+                    TENSORPRODUCT_PATCH_MESH    = 7
+                end
+
+                field   :PatternType,           :Type => Integer, :Default => Pattern::Type::SHADING, :Required => true
+                field   :Shading,               :Type => [ Dictionary, Stream ], :Required => true
+                field   :Matrix,                :Type => Array.of(Number, length: 6), :Default => [ 1, 0, 0, 1, 0, 0 ]
+                field   :ExtGState,             :Type => ExtGState
+
+                # Fields common to all shading objects.
+                module ShadingObject
+                    def self.included(receiver)
+                        receiver.field   :ShadingType,         :Type => Integer, :Required => true
+                        receiver.field   :ColorSpace,          :Type => [ Name, Array ], :Required => true
+                        receiver.field   :Background,          :Type => Array
+                        receiver.field   :BBox,                :Type => Rectangle
+                        receiver.field   :AntiAlias,           :Type => Boolean, :Default => false
+                    end
+                end
+
+                # Fields common to all Mesh shadings.
+                module Mesh
+                    def self.included(receiver)
+                        receiver.field   :BitsPerCoordinate,   :Type => Integer, :Required => true
+                        receiver.field   :BitsPerComponent,    :Type => Integer, :Required => true
+                        receiver.field   :Decode,              :Type => Array.of(Number), :Required => true
+                        receiver.field   :Function,            :Type => [ Dictionary, Stream ]
+                    end
+                end
+
+                class FunctionBased < Dictionary
+                    include StandardObject
+                    include ShadingObject
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::FUNCTION_BASED, :Required => true
+                    field   :Domain,              :Type => Array.of(Number, length: 4), :Default => [ 0.0, 1.0, 0.0, 1.0 ]
+                    field   :Matrix,              :Type => Array.of(Number, length: 6), :Default => [ 1, 0, 0, 1, 0, 0 ]
+                    field   :Function,            :Type => [ Dictionary, Stream ], :Required => true
+                end
+
+                class Axial < Dictionary
+                    include StandardObject
+                    include ShadingObject
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::AXIAL, :Required => true
+                    field   :Coords,              :Type => Array.of(Number, length: 4), :Required => true
+                    field   :Domain,              :Type => Array.of(Number, length: 2), :Default => [ 0.0, 1.0 ]
+                    field   :Function,            :Type => [ Dictionary, Stream ], :Required => true
+                    field   :Extend,              :Type => Array.of(Boolean, length: 2), :Default => [ false, false ]
+                end
+
+                class Radial < Dictionary
+                    include StandardObject
+                    include ShadingObject
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::RADIAL, :Required => true
+                    field   :Coords,              :Type => Array.of(Number, length: 6), :Required => true
+                    field   :Domain,              :Type => Array.of(Number, length: 2), :Default => [ 0.0, 1.0 ]
+                    field   :Function,            :Type => [ Dictionary, Stream ], :Required => true
+                    field   :Extend,              :Type => Array.of(Boolean, length: 2), :Default => [ false, false ]
+                end
+
+                class FreeFormTriangleMesh < Stream
+                    include ShadingObject
+                    include Mesh
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::FREEFORM_TRIANGLE_MESH, :Required => true
+                    field   :BitsPerFlag,         :Type => Integer, :Required => true
+                end
+
+                class LatticeFormTriangleMesh < Stream
+                    include ShadingObject
+                    include Mesh
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::LATTICEFORM_TRIANGLE_MESH, :Required => true
+                    field   :VerticesPerRow,      :Type => Integer, :Required => true
+                end
+
+                class CoonsPathMesh < Stream
+                    include ShadingObject
+                    include Mesh
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::COONS_PATCH_MESH, :Required => true
+                    field   :BitsPerFlag,         :Type => Integer, :Required => true
+                end
+
+                class TensorProductPatchMesh < Stream
+                    include ShadingObject
+
+                    field   :ShadingType,         :Type => Integer, :Default => Shading::Type::TENSORPRODUCT_PATCH_MESH, :Required => true
+                    field   :BitsPerFlag,         :Type => Integer, :Required => true
+                end
+            end
+
+        end
+    end
+
+    class PDF::Instruction
+        insn 'sh',  Name do |canvas, shading|
+            canvas.paint_shading(shading)
+        end
+    end
+
+end