origami 2.0.0 → 2.0.1

data/lib/origami/filters/predictors.rb

@@ -26,6 +26,7 @@ module Origami
         end
 
         module Predictor
+
             NONE = 1
             TIFF = 2
             PNG_NONE = 10
@@ -35,42 +36,88 @@ module Origami
             PNG_PAETH = 14
             PNG_OPTIMUM = 15
 
-            def self.do_pre_prediction(data, predictor: NONE, colors: 1, bpc: 8, columns: 1)
-                return data if predictor == NONE
+            class DecodeParms < Dictionary
+                include StandardObject
 
-                unless (1..4) === colors.to_i
-                    raise PredictorError.new("Colors must be between 1 and 4", input_data: data)
-                end
+                field   :Predictor,         :Type => Integer, :Default => 1
+                field   :Colors,            :Type => Integer, :Default => 1
+                field   :BitsPerComponent,  :Type => Integer, :Default => 8
+                field   :Columns,           :Type => Integer, :Default => 1
+            end
 
-                unless [1,2,4,8,16].include?(bpc.to_i)
-                    raise PredictorError.new("BitsPerComponent must be in 1, 2, 4, 8 or 16", input_data: data)
-                end
+            def self.included(receiver)
+                raise TypeError, "Predictors only applies to Filters" unless receiver.include?(Filter)
+            end
 
-                # components per line
-                nvals = columns * colors
+            #
+            # Create a new predictive Filter.
+            # _parameters_:: A hash of filter options.
+            #
+            def initialize(parameters = {})
+                super(DecodeParms.new(parameters))
+            end
 
-                # bytes per pixel
-                bpp = (colors * bpc + 7) >> 3
+            private
 
-                # bytes per row
-                bpr = (nvals * bpc + 7) >> 3
+            def pre_prediction(data)
+                return data unless @params.Predictor.is_a?(Integer)
+
+                apply_pre_prediction(data, prediction_parameters)
+            end
+
+            def post_prediction(data)
+                return data unless @params.Predictor.is_a?(Integer)
+
+                apply_post_prediction(data, prediction_parameters)
+            end
+
+            def prediction_parameters
+                {
+                    predictor:  @params.Predictor.to_i,
+                    colors:     @params.Colors.is_a?(Integer) ? @params.Colors.to_i : 1,
+                    bpc:        @params.BitsPerComponent.is_a?(Integer) ? @params.BitsPerComponent.to_i : 8,
+                    columns:    @params.Columns.is_a?(Integer) ? @params.Columns.to_i : 1,
+                }
+            end
+
+            def apply_pre_prediction(data, predictor: NONE, colors: 1, bpc: 8, columns: 1)
+                return data if predictor == NONE
+
+                bpp, bpr = compute_bpp_bpr(data, columns, colors, bpc)
 
                 unless data.size % bpr == 0
-                    raise PredictorError.new("Invalid data size #{data.size}, should be multiple of bpr=#{bpr}", input_data: data)
+                    raise PredictorError.new("Invalid data size #{data.size}, should be multiple of bpr=#{bpr}",
+                                             input_data: data)
                 end
 
                 if predictor == TIFF
-                    do_tiff_pre_prediction(data, colors, bpc, columns)
+                    tiff_pre_prediction(data, colors, bpc, columns)
                 elsif predictor >= 10 # PNG
-                    do_png_pre_prediction(data, predictor, bpp, bpr)
+                    png_pre_prediction(data, predictor, bpp, bpr)
                 else
                     raise PredictorError.new("Unknown predictor : #{predictor}", input_data: data)
                 end
             end
 
-            def self.do_post_prediction(data, predictor: NONE, colors: 1, bpc: 8, columns: 1)
+            def apply_post_prediction(data, predictor: NONE, colors: 1, bpc: 8, columns: 1)
                 return data if predictor == NONE
 
+                bpp, bpr = compute_bpp_bpr(data, columns, colors, bpc)
+
+                if predictor == TIFF
+                    tiff_post_prediction(data, colors, bpc, columns)
+                elsif predictor >= 10 # PNG
+                    # Each line has an extra predictor byte.
+                    png_post_prediction(data, bpp, bpr + 1)
+                else
+                    raise PredictorError.new("Unknown predictor : #{predictor}", input_data: data)
+                end
+            end
+
+            #
+            # Computes the number of bytes per pixel and number of bytes per row.
+            #
+            def compute_bpp_bpr(data, columns, colors, bpc)
                 unless (1..4) === colors
                     raise PredictorError.new("Colors must be between 1 and 4", input_data: data)
                 end
@@ -86,18 +133,16 @@ module Origami
                 bpp = (colors * bpc + 7) >> 3
 
                 # bytes per row
-                bpr = ((nvals * bpc + 7) >> 3) + 1
+                bpr = (nvals * bpc + 7) >> 3
 
-                if predictor == TIFF
-                    do_tiff_post_prediction(data, colors, bpc, columns)
-                elsif predictor >= 10 # PNG
-                    do_png_post_prediction(data, bpp, bpr)
-                else
-                    raise PredictorError.new("Unknown predictor : #{predictor}", input_data: data)
-                end
+                [ bpp, bpr ]
             end
 
-            def self.do_png_post_prediction(data, bpp, bpr)
+            #
+            # Decodes the PNG input data.
+            # Each line should be prepended by a byte identifying a PNG predictor.
+            #
+            def png_post_prediction(data, bpp, bpr)
                 result = ""
                 uprow = "\0" * bpr
                 thisrow = "\0" * bpr
@@ -114,37 +159,18 @@ module Origami
                         if bpp > i
                             left = upleft = 0
                         else
-                            left = line[i-bpp].ord
-                            upleft = uprow[i-bpp].ord
+                            left = line[i - bpp].ord
+                            upleft = uprow[i - bpp].ord
                         end
 
-                        case predictor
-                        when PNG_NONE
-                            thisrow = line
-                        when PNG_SUB
-                            thisrow[i] = ((line[i].ord + left) & 0xFF).chr
-                        when PNG_UP
-                            thisrow[i] = ((line[i].ord + up) & 0xFF).chr
-                        when PNG_AVERAGE
-                            thisrow[i] = ((line[i].ord + ((left + up) / 2)) & 0xFF).chr
-                        when PNG_PAETH
-                            p = left + up - upleft
-                            pa, pb, pc = (p - left).abs, (p - up).abs, (p - upleft).abs
-
-                            thisrow[i] = ((line[i].ord +
-                                case [ pa, pb, pc ].min
-                                when pa then left
-                                when pb then up
-                                when pc then upleft
-                                end
-                            ) & 0xFF).chr
-                        else
-                            unless Origami::OPTIONS[:ignore_png_errors]
-                                raise PredictorError.new("Unknown PNG predictor : #{predictor}", input_data: data, decoded_data: result)
-                            end
+                        begin
+                            thisrow[i] = png_apply_prediction(predictor, line[i].ord, up, left, upleft, &:+)
+                        rescue PredictorError => error
+                            thisrow[i] = line[i] if Origami::OPTIONS[:ignore_png_errors]
 
-                            # behave as PNG_NONE
-                            thisrow = line
+                            error.input_data = data
+                            error.decoded_data = result
+                            raise(error)
                         end
                     end
 
@@ -155,47 +181,29 @@ module Origami
                 result
             end
 
-            def self.do_png_pre_prediction(data, predictor, bpp, bpr)
+            #
+            # Encodes the input data given a PNG predictor.
+            #
+            def png_pre_prediction(data, predictor, bpp, bpr)
                 result = ""
                 nrows = data.size / bpr
 
                 line = "\0" + data[-bpr, bpr]
 
-                (nrows-1).downto(0) do |irow|
+                (nrows - 1).downto(0) do |irow|
                     uprow =
                     if irow == 0
-                        "\0" * (bpr+1)
+                        "\0" * (bpr + 1)
                     else
-                        "\0" + data[(irow-1)*bpr,bpr]
+                        "\0" + data[(irow - 1) * bpr, bpr]
                     end
 
                     bpr.downto(1) do |i|
                         up = uprow[i].ord
-                        left = line[i-bpp].ord
-                        upleft = uprow[i-bpp].ord
-
-                        case predictor
-                        when PNG_SUB
-                            line[i] = ((line[i].ord - left) & 0xFF).chr
-                        when PNG_UP
-                            line[i] = ((line[i].ord - up) & 0xFF).chr
-                        when PNG_AVERAGE
-                            line[i] = ((line[i].ord - ((left + up) / 2)) & 0xFF).chr
-                        when PNG_PAETH
-                            p = left + up - upleft
-                            pa, pb, pc = (p - left).abs, (p - up).abs, (p - upleft).abs
-
-                            line[i] = ((line[i].ord -
-                                case [ pa, pb, pc ].min
-                                when pa then left
-                                when pb then up
-                                when pc then upleft
-                                end
-                            ) & 0xFF).chr
-                        when PNG_NONE
-                        else
-                            raise PredictorError.new("Unsupported PNG predictor : #{predictor}", input_data: data)
-                        end
+                        left = line[i - bpp].ord
+                        upleft = uprow[i - bpp].ord
+
+                        line[i] = png_apply_prediction(predictor, line[i].ord, up, left, upleft, &:-)
                     end
 
                     line[0] = (predictor - 10).chr
@@ -207,32 +215,54 @@ module Origami
                 result
             end
 
-            def self.do_tiff_post_prediction(data, colors, bpc, columns) #:nodoc:
-                bpr = (colors * bpc * columns + 7) >> 3
-                nrows = data.size / bpr
-                bitmask = (1 << bpc) - 1
-                result = Utils::BitWriter.new
-
-                nrows.times do |irow|
-                    line = Utils::BitReader.new(data[irow * bpr, bpr])
-
-                    pixel = ::Array.new(colors, 0)
-                    columns.times do
-                        diffpixel = ::Array.new(colors) { line.read(bpc) }
-                        pixel = pixel.zip(diffpixel).map!{|c, diff| (c + diff) & bitmask}
-
-                        pixel.each do |c|
-                            result.write(c, bpc)
-                        end
+            #
+            # Computes the next component value given a predictor and adjacent components.
+            # A block must be passed to apply the operation.
+            #
+            def png_apply_prediction(predictor, value, up, left, upleft)
+
+                result =
+                    case predictor
+                    when PNG_NONE
+                        value
+                    when PNG_SUB
+                        yield(value, left)
+                    when PNG_UP
+                        yield(value, up)
+                    when PNG_AVERAGE
+                        yield(value, (left + up) / 2)
+                    when PNG_PAETH
+                        yield(value, png_paeth_choose(up, left, upleft))
+                    else
+                        raise PredictorError, "Unsupported PNG predictor : #{predictor}"
                     end
 
-                    result.final
+                (result & 0xFF).chr
+            end
+
+            #
+            # Choose the preferred value in a PNG paeth predictor given the left, up and up left samples.
+            #
+            def png_paeth_choose(left, up, upleft)
+                p = left + up - upleft
+                pa, pb, pc = (p - left).abs, (p - up).abs, (p - upleft).abs
+
+                case [pa, pb, pc].min
+                when pa then left
+                when pb then up
+                when pc then upleft
                 end
+            end
 
-                result.final.to_s
+            def tiff_post_prediction(data, colors, bpc, columns) #:nodoc:
+                tiff_apply_prediction(data, colors, bpc, columns, &:+)
+            end
+
+            def tiff_pre_prediction(data, colors, bpc, columns) #:nodoc:
+                tiff_apply_prediction(data, colors, bpc, columns, &:-)
             end
 
-            def self.do_tiff_pre_prediction(data, colors, bpc, columns) #:nodoc:
+            def tiff_apply_prediction(data, colors, bpc, columns) #:nodoc:
                 bpr = (colors * bpc * columns + 7) >> 3
                 nrows = data.size / bpr
                 bitmask = (1 << bpc) - 1
@@ -244,7 +274,7 @@ module Origami
                     diffpixel = ::Array.new(colors, 0)
                     columns.times do
                         pixel = ::Array.new(colors) { line.read(bpc) }
-                        diffpixel = diffpixel.zip(pixel).map!{|diff, c| (c - diff) & bitmask}
+                        diffpixel = diffpixel.zip(pixel).map!{|diff, c| yield(c, diff) & bitmask}
 
                         diffpixel.each do |c|
                             result.write(c, bpc)

data/lib/origami/filters/runlength.rb

@@ -42,36 +42,24 @@ module Origami
                 i = 0
 
                 while i < stream.size
-                    #
+
                     # How many identical bytes coming?
-                    #
-                    length = 1
-                    while i+1 < stream.size and length < EOD and stream[i] == stream[i+1]
-                        length = length + 1
-                        i = i + 1
-                    end
+                    length = compute_run_length(stream, i)
 
-                    #
                     # If more than 1, then compress them.
-                    #
                     if length > 1
                         result << (257 - length).chr << stream[i]
-                    #
+                        i += length
+
                     # Otherwise how many different bytes to copy?
-                    #
                     else
-                        j = i
-                        while j+1 < stream.size and (j - i + 1) < EOD and stream[j] != stream[j+1]
-                            j = j + 1
-                        end
+                        next_pos = find_next_run(stream, i)
+                        length = next_pos - i
 
-                        length = j - i
-                        result << length.chr << stream[i, length+1]
+                        result << (length - 1).chr << stream[i, length]
 
-                        i = j
+                        i += length
                     end
-
-                    i = i + 1
                 end
 
                 result << EOD.chr
@@ -83,7 +71,6 @@ module Origami
             #
             def decode(stream)
                 result = "".b
-                return result if stream.empty?
 
                 i = 0
                 until i >= stream.length or stream[i].ord == EOD do
@@ -104,12 +91,37 @@ module Origami
                 end
 
                 # Check if offset is beyond the end of data.
-                if i >= stream.length
+                if i > stream.length
                     raise InvalidRunLengthDataError.new("Truncated run-length data", input_data: stream, decoded_data: result)
                 end
 
                 result
             end
+
+            private
+
+            #
+            # Find the position of the next byte at which a new run starts.
+            #
+            def find_next_run(input, pos)
+                start = pos
+                pos += 1 while pos + 1 < input.size and (pos - start + 1) < EOD and input[pos] != input[pos + 1]
+
+                pos + 1
+            end
+
+            #
+            # Computes the length of the run at the given position.
+            #
+            def compute_run_length(input, pos)
+                run_length = 1
+                while pos + 1 < input.size and run_length < EOD and input[pos] == input[pos + 1]
+                    run_length += 1
+                    pos += 1
+                end
+
+                run_length
+            end
         end
         RL = RunLength
 

data/lib/origami/graphics.rb

@@ -29,10 +29,10 @@ module Origami
 end
 
 require 'origami/graphics/instruction'
+require 'origami/graphics/state'
 require 'origami/graphics/colors'
 require 'origami/graphics/path'
 require 'origami/graphics/xobject'
-require 'origami/graphics/patterns'
 require 'origami/graphics/text'
-require 'origami/graphics/state'
+require 'origami/graphics/patterns'
 require 'origami/graphics/render'

data/lib/origami/graphics/colors.rb

@@ -105,99 +105,125 @@ module Origami
             def Color.to_a(color)
                 return color if color.is_a?(::Array)
 
-                if (color.respond_to? :r and color.respond_to? :g and color.respond_to? :b)
-                    r = (color.respond_to?(:r) ? color.r : color[0]).to_f / 255
-                    g = (color.respond_to?(:g) ? color.g : color[1]).to_f / 255
-                    b = (color.respond_to?(:b) ? color.b : color[2]).to_f / 255
+                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 (color.respond_to? :c and color.respond_to? :m and color.respond_to? :y and color.respond_to? :k)
-                    c = (color.respond_to?(:c) ? color.c : color[0]).to_f
-                    m = (color.respond_to?(:m) ? color.m : color[1]).to_f
-                    y = (color.respond_to?(:y) ? color.y : color[2]).to_f
-                    k = (color.respond_to?(:k) ? color.k : color[3]).to_f
+                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 or (0.0..1.0) === color
-                    g = color.respond_to?(:g) ? color.g : color
-                    return [ g ]
+                elsif color.respond_to?(:g)
+                    g = color.g
+                    return [g]
 
                 else
                     raise TypeError, "Invalid color : #{color}"
                 end
             end
         end
-    end
 
-    class PDF::Instruction
+        class State
+            def set_stroking_color(color, space = @stroking_color_space)
+                check_color(space, color) 
+
+                @stroking_colorspace = space
+                @stroking_color = color
+            end
 
-        insn  'CS', Name do |canvas, cs| canvas.gs.stroking_colorspace = cs end
-        insn  'cs', Name do |canvas, cs| canvas.gs.nonstroking_colorspace = cs end
-        insn  'SC', '*' do |canvas, *c| canvas.gs.stroking_color = c end
-        insn  'sc', '*' do |canvas, *c| canvas.gs.nonstroking_color = c end
+            def set_nonstroking_color(color, space = @nonstroking_colorspace)
+                check_color(space, color)
 
-        insn  'G', Real do |canvas, c|
-            unless (0..1).include? c
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceGray: #{c}"
+                @nonstroking_colorspace = space
+                @nonstroking_color = color
             end
 
-            canvas.gs.stroking_colorspace = Graphics::Color::Space::DEVICE_GRAY
-            canvas.gs.stroking_color = [ c ]
-        end
+            def set_stroking_colorspace(space)
+                check_color_space(space, @stroking_color)
 
-        insn  'g', Real do |canvas, c|
-            unless (0..1).include? c
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceGray: #{c}"
+                @stroking_color_space = space
             end
 
-            canvas.gs.nonstroking_colorspace = Graphics::Color::Space::DEVICE_GRAY
-            canvas.gs.nonstroking_color = [ c ]
-        end
+            def set_nonstroking_colorspace(space)
+                check_color_space(space, @nonstroking_color)
 
-        insn  'RG', Real, Real, Real do |canvas, r,g,b|
-            color = [ r, g, b ]
-            unless color.all? {|comp| (0..1).include? comp}
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceRGB: #{color.inspect}"
+                @nonstroking_color_space = space
             end
 
-            canvas.gs.stroking_colorspace = Graphics::Color::Space::DEVICE_RGB
-            canvas.gs.stroking_color = color
-        end
+            private
 
-        insn  'rg', Real, Real, Real do |canvas, r,g,b|
-            color = [ r, g, b ]
-            unless color.all? {|comp| (0..1).include? comp}
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceRGB: #{color.inspect}"
+            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
 
-            canvas.gs.nonstroking_colorspace = Graphics::Color::Space::DEVICE_RGB
-            canvas.gs.nonstroking_color = color
-        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
 
-        insn  'K', Real, Real, Real, Real do |canvas, c,m,y,k|
-            color = [ c, m, y, k ]
-            unless color.all? {|comp| (0..1).include? comp}
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceCMYK: #{color.inspect}"
+                raise InvalidColorError, "Invalid color #{color.inspect} for #{space}" unless valid_color
             end
 
-            canvas.gs.stroking_colorspace = Graphics::Color::Space::DEVICE_CMYK
-            canvas.gs.stroking_color = color
-        end
+            def check_gray_color(color)
+                color.is_a?(::Array) and color.length == 1 and (0..1).include?(color[0])
+            end
 
-        insn  'k', Real, Real, Real, Real do |canvas, c,m,y,k|
-            color = [ c, m, y, k ]
-            unless color.all? {|comp| (0..1).include? comp}
-                raise Graphics::InvalidColorError,
-                        "Not a valid color for DeviceCMYK: #{color.inspect}"
+            def check_rgb_color(color)
+                color.is_a?(::Array) and color.length == 3 and color.all? {|c| (0..1).include?(c) }
             end
 
-            canvas.gs.nonstroking_colorspace = Graphics::Color::Space::DEVICE_CMYK
-            canvas.gs.nonstroking_color = color
+            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