png 1.1.0 → 1.2.0

data.tar.gz.sig

@@ -0,0 +1,2 @@
+iʍ��/�7]L��;�OP�C��TZ3W��=�*�̒]}9���؃������o2�Њ�
+4��.���v��ud�L-f�ҹ�ns�%�<���STaXt�p[�+�W��_�}�wyәv�X�}�õ�e!{PEEAz��@�h�c�&^�,�Z˥[�`Ï7�yʈv��qK�^��C)��{�5����

data/History.txt

@@ -1,18 +1,60 @@
-*** 1.1.0 / 2007-03-26
-
-+ 4 major enhancements:
-    + Fixed and incorporated Dominik Barathon's optimizations.
-    + Wrote inline methods for png_crc and png_join. Now about 15x faster overall.
-    + Basic PNG loading.
-    + Reoriented x/y origin to bottom left. This will break things!
-+ 3 minor enhancements:
-    + Awesome ascii art patches from Tom Werner: Canvas#inpsect, Canvas#to_s, Color#to_ascii.
-    + Switched to Hoe.
-    + PNG.pie_chart from png/pie.
-+ 1 bug fix:
-    + Fixed bug in PNG::Canvas#each.
-
-*** 1.0.0 / 2006-09-31
-
-+ Birthday!
+=== 1.2.0 / 2009-06-23
+
+* 26 minor enhancements:
+
+  * Add load_metadata flag to PNG.load to extract dimensions and depth.
+  * Add pure-ruby versions back for png_join and png_crc.
+  * Added Canvas#composite(canvas, x, y, style) with overwrite, underlay, overlay, and blend.
+  * Added Canvas#each, passes x, y, color.
+  * Added Canvas#extract.
+  * Added Color#|, Background color is effective false.
+  * Added Font#coordinates and cached each letter when extracted.
+  * Added PNG::load_file.
+  * Added reader tests.
+  * Added tests for PNG::Font.
+  * Added tests for PNG::load.
+  * Added to/from hsv methods to Color.
+  * Clean up tests to remove duplication.
+  * Cleaned up Color#to_ascii to make much easier to read and extend.
+  * Cleaned up a fair amount of code, removing as many raw literals as possible.
+  * Color#blend is a simple averaging algorithm now.
+  * Extended reader to include RGB as well, paving the way for grayscale.
+  * Fake support for RGB as well as RGBA (default alpha to 255).
+  * Made reader work again (was flipped and all sorts of broken).
+  * Split out reader.
+  * Switched to minitest.
+  * Time to refactor PNG::Font to use #extract and #composite...
+  * Updated Rakefile to new hoe capabilities.
+  * Updated manifest.
+  * metadata_only now cleaner.
+  * read_IHDR now returns height, width instead of a canvas.
+
+* 3 bug fixes:
+
+  * Fixed example/lines and added text.
+  * Fixes for 1.9.
+  * Ignore color profile if it exists (fixes problems on osx screenshots).
+
+=== 1.1.0 / 2007-03-26
+
+* 4 major enhancements:
+
+    * Fixed and incorporated Dominik Barathon's optimizations.
+    * Wrote inline methods for png_crc and png_join. Now about 15x faster overall.
+    * Basic PNG loading.
+    * Reoriented x/y origin to bottom left. This will break things!
+
+* 3 minor enhancements:
+
+    * Awesome ascii art patches from Tom Werner: Canvas#inpsect, Canvas#to_s, Color#to_ascii.
+    * Switched to Hoe.
+    * PNG.pie_chart from png/pie.
+
+* 1 bug fix:
+
+    * Fixed bug in PNG::Canvas#each.
+
+=== 1.0.0 / 2006-09-31
+
+* Birthday!
 

data/Manifest.txt

@@ -6,5 +6,10 @@ example/lines.rb
 example/profile.rb
 example/profile_lines.rb
 lib/png.rb
+lib/png/default_font.png
+lib/png/font.rb
 lib/png/pie.rb
+lib/png/reader.rb
 test/test_png.rb
+test/test_png_font.rb
+test/test_png_reader.rb

data/Rakefile

@@ -1,17 +1,18 @@
-require 'hoe'
-require './lib/png.rb'
+$: << "../../RubyInline/dev/lib"
+$: << "../../hoe/dev/lib"
 
-Hoe.new 'png', PNG::VERSION do |s|
-  s.rubyforge_name = 'seattlerb'
-  s.author = ['Ryan Davis', 'Eric Hodel']
-  s.email = 'support@zenspider.com'
+require 'hoe'
 
-  s.summary = 'An almost-pure-ruby PNG library'
-  s.description = s.paragraphs_of('README.txt', 3..7).join("\n\n")
+Hoe.add_include_dirs "../../hoe/dev/lib" # HACK remove
+Hoe.add_include_dirs "../../RubyInline/dev/lib", "lib"
+Hoe.plugin :seattlerb
+Hoe.plugin :inline
 
-  s.changes = s.paragraphs_of('History.txt', 0..1).join("\n\n")
+Hoe.spec 'png' do
+  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
+  developer 'Eric Hodel', 'drbrain@segment7.net'
 
-  s.extra_deps << ['RubyInline', '>= 3.5.0']
+  self.rubyforge_name = 'seattlerb'
 end
 
 # vim: syntax=Ruby

data/example/lines.rb

@@ -1,18 +1,9 @@
 #!/usr/local/bin/ruby -w
 
 require 'png'
+require 'png/font'
 
-canvas = PNG::Canvas.new 1024, 1024, PNG::Color::White
-
-#canvas.each do |x, y|
-#  case x
-#  when y then
-#    canvas.point(x, y, Color::Black)
-#  when 50 then
-#    canvas.point(x, y, Color::Background)
-#  end
-#  canvas.point(x, y, Color::Green) if y = 200
-#end
+canvas = PNG::Canvas.new 201, 201, PNG::Color::White
 
 canvas.line  50,  50, 100,  50, PNG::Color::Blue
 canvas.line  50,  50,  50, 100, PNG::Color::Blue
@@ -22,7 +13,8 @@ canvas.line 100,  50, 200,  75, PNG::Color::Green
 canvas.line   0, 200, 200,   0, PNG::Color::Black
 canvas.line   0, 200, 150,   0, PNG::Color::Red
 
+canvas.annotate 'Hello World', 10, 10
+
 png = PNG.new canvas
 png.save 'blah.png'
 `open blah.png`
-

data/lib/png.rb

@@ -1,29 +1,26 @@
-begin; require 'rubygems'; rescue LoadError; end
+# encoding: BINARY
+
+require 'rubygems'
 require 'zlib'
 require 'inline'
 
-class String # :nodoc: # ZenTest SKIP
-
-  ##
-  # Calculates a CRC using the algorithm in the PNG specification.
+unless "".respond_to? :getbyte then
+  class String
+    alias :getbyte :[]
+  end
+end
 
+class String # :nodoc: # ZenTest SKIP
   inline do |builder|
-    if RUBY_VERSION < "1.8.6" then
-      builder.prefix <<-EOM
-        #define RSTRING_PTR(s) (RSTRING(s)->ptr)
-        #define RSTRING_LEN(s) (RSTRING(s)->len)
-      EOM
-    end
-
     builder.c <<-EOM
       unsigned long png_crc() {
         static unsigned long crc[256];
         static char crc_table_computed = 0;
-      
+
         if (! crc_table_computed) {
           unsigned long c;
           int n, k;
-        
+
           for (n = 0; n < 256; n++) {
             c = (unsigned long) n;
             for (k = 0; k < 8; k++) {
@@ -35,8 +32,8 @@ class String # :nodoc: # ZenTest SKIP
         }
 
         unsigned long c = 0xffffffff;
-        unsigned len = RSTRING_LEN(self);
-        char * s = StringValuePtr(self);
+        unsigned len    = RSTRING_LEN(self);
+        char * s        = StringValuePtr(self);
         unsigned i;
 
         for (i = 0; i < len; i++) {
@@ -47,6 +44,30 @@ class String # :nodoc: # ZenTest SKIP
       }
     EOM
   end
+rescue CompilationError => e
+  warn "COMPLIATION ERROR: #{e}"
+
+  unless defined? @@crc then
+    @@crc = Array.new(256)
+    256.times do |n|
+      c = n
+      8.times do
+        c = (c & 1 == 1) ? 0xedb88320 ^ (c >> 1) : c >> 1
+      end
+      @@crc[n] = c
+    end
+  end
+
+  ##
+  # Calculates a CRC using the algorithm in the PNG specification.
+
+  def png_crc()
+    c = 0xffffffff
+    each_byte do |b|
+      c = @@crc[(c^b) & 0xff] ^ (c >> 8)
+    end
+    return c ^ 0xffffffff
+  end
 end
 
 ##
@@ -71,47 +92,69 @@ end
 #   canvas.line 50, 50, 100, 50, PNG::Color::Blue
 #   png = PNG.new canvas
 #   png.save 'blah.png'
+#
+# = TODO:
+#
+# + Get everything orinted entirely on [x,y,h,w] with x,y origin being
+#   bottom left.
 
 class PNG
-
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
   SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10].pack("C*")
 
-  inline do |builder|
-    if RUBY_VERSION < "1.8.6" then
-      builder.prefix <<-EOM
-        #define RARRAY_PTR(s) (RARRAY(s)->ptr)
-        #define RARRAY_LEN(s) (RARRAY(s)->len)
-      EOM
-    end
+  # Color Types:
+  GRAY    = 0 # DEPTH = 1,2,4,8,16
+  RGB     = 2 # DEPTH = 8,16
+  INDEXED = 3 # DEPTH = 1,2,4,8
+  GRAYA   = 4 # DEPTH = 8,16
+  RGBA    = 6 # DEPTH = 8,16
+
+  # Filter Types:
+  NONE    = 0
+  SUB     = 1
+  UP      = 2
+  AVG     = 3
+  PAETH   = 4
+
+  begin
+    inline do |builder|
+      if RUBY_VERSION < "1.8.6" then
+        builder.prefix <<-EOM
+          #define RARRAY_PTR(s) (RARRAY(s)->ptr)
+          #define RARRAY_LEN(s) (RARRAY(s)->len)
+        EOM
+      end
 
-    # C equivalent of:
-    # @data.map { |row| "\0" + row.map { |p| p.values }.join }.join
-    builder.c <<-EOM
-      VALUE png_join() {
-        int i, j;
-        VALUE data = rb_iv_get(self, "@data");
-        unsigned int data_len = RARRAY_LEN(data);
-        unsigned int row_len = RARRAY_LEN(RARRAY_PTR(data)[0]);
-        unsigned long size = data_len * (1 + (row_len * 4));
-        char * result = malloc(size);
-        unsigned long idx = 0;
-        for (i = 0; i < data_len; i++) {
-          VALUE row = RARRAY_PTR(data)[i];
-          result[idx++] = 0;
-          for (j = 0; j < row_len; j++) {
-            VALUE color = RARRAY_PTR(row)[j];
-            VALUE values = rb_iv_get(color, "@values");
-            char * value = StringValuePtr(values);
-            result[idx++] = value[0];
-            result[idx++] = value[1];
-            result[idx++] = value[2];
-            result[idx++] = value[3];
-          }          
+      builder.c <<-EOM
+        VALUE png_join() {
+          int i, j;
+          VALUE data = rb_iv_get(self, "@data");
+          unsigned int data_len = RARRAY_LEN(data);
+          unsigned int row_len = RARRAY_LEN(RARRAY_PTR(data)[0]);
+          unsigned long size = data_len * (1 + (row_len * 4));
+          char * result = malloc(size);
+          unsigned long idx = 0;
+          for (i = 0; i < data_len; i++) {
+            VALUE row = RARRAY_PTR(data)[i];
+            result[idx++] = 0;
+            for (j = 0; j < row_len; j++) {
+              VALUE color = RARRAY_PTR(row)[j];
+              VALUE values = rb_iv_get(color, "@values");
+              char * value = StringValuePtr(values);
+              result[idx++] = value[0];
+              result[idx++] = value[1];
+              result[idx++] = value[2];
+              result[idx++] = value[3];
+            }
+          }
+          return rb_str_new(result, size);
         }
-        return rb_str_new(result, size);
-      }
-    EOM
+      EOM
+    end
+  rescue CompilationError
+    def png_join
+      @data.map { |row| "\0" + row.map { |p| p.values }.join }.join
+    end
   end
 
   ##
@@ -121,116 +164,6 @@ class PNG
     [data.size, type, data, (type + data).png_crc].pack("Na*a*N")
   end
 
-  def self.load(png)
-    png = png.dup
-    signature = png.slice! 0, 8
-    raise ArgumentError, 'Invalid PNG signature' unless signature == SIGNATURE
-
-    type, data = read_chunk png
-
-    raise ArgumentError, 'Invalid PNG, no IHDR chunk' unless type == 'IHDR'
-
-    canvas = read_IHDR data
-    type, data = read_chunk png
-    read_IDAT data, canvas
-    type, data = read_chunk png
-    raise 'oh no! IEND not next? crashing and burning!' unless type == 'IEND'
-
-    new canvas
-  end
-
-  def self.check_crc(type, data, crc)
-    return true if (type + data).png_crc == crc
-    raise ArgumentError, "Invalid CRC encountered in #{type} chunk"
-  end
-
-  def self.paeth(a, b, c) # left, above, upper left
-    p = a + b - c
-    pa = (p - a).abs
-    pb = (p - b).abs
-    pc = (p - c).abs
-
-    return a if pa <= pb && pa <= pc
-    return b if pb <= pc
-    c
-  end
-
-  def self.read_chunk(png)
-    size, type = png.slice!(0, 8).unpack 'Na4'
-    data, crc = png.slice!(0, size + 4).unpack "a#{size}N"
-
-    check_crc type, data, crc
-
-    return type, data
-  end
-
-  def self.read_IDAT(data, canvas)
-    data = Zlib::Inflate.inflate(data).unpack 'C*'
-    scanline_length = 4 * canvas.width + 1 # for filter
-    row = 0
-    until data.empty? do
-      row_data = data.slice! 0, scanline_length
-      filter = row_data.shift
-      case filter
-      when 0 then # None
-      when 1 then # Sub
-        row_data.each_with_index do |byte, index|
-          left = index < 4 ? 0 : row_data[index - 4]
-          row_data[index] = (byte + left) % 256
-          #p [byte, left, row_data[index]]
-        end
-      when 2 then # Up
-        row_data.each_with_index do |byte, index|
-          col = index / 4
-          upper = row == 0 ? 0 : canvas[col, row - 1].values[index % 4]
-          row_data[index] = (upper + byte) % 256
-        end
-      when 3 then # Average
-        row_data.each_with_index do |byte, index|
-          col = index / 4
-          upper = row == 0 ? 0 : canvas[col, row - 1].values[index % 4]
-          left = index < 4 ? 0 : row_data[index - 4]
-
-          row_data[index] = (byte + ((left + upper)/2).floor) % 256
-        end
-      when 4 then # Paeth
-        left = upper = upper_left = nil
-        row_data.each_with_index do |byte, index|
-          col = index / 4
-
-          left = index < 4 ? 0 : row_data[index - 4]
-          if row == 0 then
-            upper = upper_left = 0
-          else
-            upper = canvas[col, row - 1].values[index % 4]
-            upper_left = col == 0 ? 0 :
-                           canvas[col - 1, row - 1].values[index % 4]
-          end
-
-          paeth = paeth left, upper, upper_left
-          row_data[index] = (byte + paeth) % 256
-          #p [byte, paeth, row_data[index]]
-        end
-      else
-        raise ArgumentError, "Invalid filter algorithm #{filter}"
-      end
-
-      col = 0
-      row_data.each_slice 4 do |slice|
-        canvas[col, row] = PNG::Color.new(*slice)
-        col += 1
-      end
-
-      row += 1
-    end
-  end
-
-  def self.read_IHDR(data)
-    width, height, *rest = data.unpack 'N2C5'
-    raise ArgumentError, 'unsupported PNG file' unless rest == [8, 6, 0, 0, 0]
-    return PNG::Canvas.new(height, width)
-  end
-
   ##
   # Creates a new PNG object using +canvas+
 
@@ -245,7 +178,9 @@ class PNG
   # Writes the PNG to +path+.
 
   def save(path)
-    File.open path, 'wb' do |f| f.write to_blob end
+    File.open path, 'wb' do |f|
+      f.write to_blob
+    end
   end
 
   ##
@@ -254,22 +189,29 @@ class PNG
   def to_blob
     blob = []
 
+    header = [@width, @height, @bits, RGBA, NONE, NONE, NONE]
+
     blob << SIGNATURE
-    blob << PNG.chunk('IHDR', [@width, @height, @bits, 6, 0, 0, 0 ].pack("N2C5"))
-    # 0 == filter type code "none"
-    data = self.png_join
-    blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(data))
+    blob << PNG.chunk('IHDR', header.pack("N2C5"))
+    blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(self.png_join))
     blob << PNG.chunk('IEND', '')
     blob.join
   end
 
   ##
-  # RGBA colors
+  # A 32 bit RGBA color. Can be created from RGB or RGBA via #new,
+  # numeric value or hex string via #from, or HSV via #from_hsv.
 
   class Color
 
+    MAX=255
+
     attr_reader :values
 
+    ##
+    # Create a new color from a string or integer value. Can take an
+    # optional name as well.
+
     def self.from str, name = nil
       str = "%08x" % str if Integer === str
       colors = str.scan(/[\da-f][\da-f]/i).map { |n| n.hex }
@@ -280,7 +222,7 @@ class PNG
     ##
     # Creates a new color with values +red+, +green+, +blue+, and +alpha+.
 
-    def initialize(red, green, blue, alpha, name = nil)
+    def initialize red, green, blue, alpha = MAX, name = nil
       @values = "%c%c%c%c" % [red, green, blue, alpha]
       @name = name
     end
@@ -303,44 +245,63 @@ class PNG
     White      = Color.from 0xFFFFFFFF, "White"
     Yellow     = Color.from 0xFFFF00FF, "Yellow"
 
-    def ==(other) # :nodoc:
+    def == other # :nodoc:
       self.class === other and other.values == values
     end
 
+    alias :eql? :==
+
+    ##
+    # "Bitwise or" as applied to colors. Background color is
+    # considered false.
+
+    def | o
+      self == Background ? o : self
+    end
+
+    def hash # :nodoc:
+      self.values.hash
+    end
+
+    ##
+    # Return an array of RGB
+
+    def rgb # TODO: rgba?
+      return r, g, b
+    end
+
     ##
     # Red component
 
-    def r; @values[0]; end
+    def r; @values.getbyte 0; end
 
     ##
     # Green component
 
-    def g; @values[1]; end
+    def g; @values.getbyte 1; end
 
     ##
     # Blue component
 
-    def b; @values[2]; end
+    def b; @values.getbyte 2; end
 
     ##
     # Alpha transparency component
 
-    def a; @values[3]; end
+    def a; @values.getbyte 3; end
 
     ##
     # Blends +color+ into this color returning a new blended color.
 
-    def blend(color)
-      return Color.new((r * (0xFF - color.a) + color.r * color.a) >> 8,
-                       (g * (0xFF - color.a) + color.g * color.a) >> 8,
-                       (b * (0xFF - color.a) + color.b * color.a) >> 8,
-                       (a * (0xFF - color.a) + color.a * color.a) >> 8)
+    def blend color
+      return Color.new(((r + color.r) / 2), ((g + color.g) / 2),
+                       ((b + color.b) / 2), ((a + color.a) / 2))
     end
 
     ##
     # Returns a new color with an alpha value adjusted by +i+.
 
-    def intensity(i)
+    def intensity i
       return Color.new(r,g,b,(a*i) >> 8)
     end
 
@@ -358,24 +319,86 @@ class PNG
 
     def to_ascii
       return '  ' if a == 0x00
+
       brightness = (((r + g + b) / 3) * a) / 0xFF
-      return '00' if brightness >= 0xc0
-      return '++' if brightness >= 0x7F
-      return ',,' if brightness >= 0x40
-      return '..'
+
+      %w(.. ,, ++ 00)[brightness / 64]
     end
 
-    def to_s
+    def to_s # :nodoc:
       if @name then
         @name
       else
         super
       end
     end
-  end
+
+    ##
+    # Creates a new RGB color from HSV equivalent values.
+
+    def self.from_hsv h, s, v
+      r = g = b = v # gray
+      unless s == 0.0 then
+        h += 255 if h < 0
+        h  = h / 255.0 * 6.0
+        s  = s / 255.0
+        v  = v / 255.0
+        i  = h.floor
+        f  = h - i
+        p = v * (1 - (s))
+        q = v * (1 - (s * (f)))
+        w = v * (1 - (s * (1-f)))
+        r, g, b = case i
+                  when 0,6 then
+                    [ v, w, p ]
+                  when 1 then
+                    [ q, v, p ]
+                  when 2 then
+                    [ p, v, w ]
+                  when 3 then
+                    [ p, q, v ]
+                  when 4 then
+                    [ w, p, v ]
+                  when 5 then
+                    [ v, p, q ]
+                  else
+                    raise [h, s, v, i, f, p, q, w].inspect
+                  end
+      end
+      self.new((r * 255).round, (g * 255).round, (b * 255).round)
+    end
+
+    ##
+    # Returns HSV equivalent of the current color.
+
+    def to_hsv # errors = 54230 out of 255^3 are off by about 1 on r, g, or b
+      rgb = self.rgb
+      r, g, b = rgb
+      h, s, v = 0, 0, rgb.max
+
+      return h, s, v if v == 0
+
+      range = v - rgb.min
+      s = 255 * range / v
+
+      return h, s, v if s == 0
+
+      h = case v
+          when r then
+            0x00 + 43 * (g - b) / range # 43 = 1/4 of 360 scaled to 255
+          when g then
+            0x55 + 43 * (b - r) / range
+          else
+            0xAA + 43 * (r - g) / range
+          end
+
+      return h.round, s.round, v.round
+    end
+  end # Color
 
   ##
-  # PNG canvas
+  # A canvas used for drawing images. Origin is 0, 0 in the bottom
+  # left corner.
 
   class Canvas
 
@@ -394,7 +417,7 @@ class PNG
 
     attr_reader :data
 
-    def initialize(width, height, background = Color::Background)
+    def initialize width, height, background = Color::Background
       @width = width
       @height = height
       @data = Array.new(@height) { |x| Array.new(@width, background) }
@@ -403,7 +426,7 @@ class PNG
     ##
     # Retrieves the color of the pixel at (+x+, +y+).
 
-    def [](x, y)
+    def [] x, y
       raise "bad x value #{x} >= #{@width}" if x >= @width
       raise "bad y value #{y} >= #{@height}" if y >= @height
       @data[@height-y-1][x]
@@ -412,12 +435,59 @@ class PNG
     ##
     # Sets the color of the pixel at (+x+, +y+) to +color+.
 
-    def []=(x, y, color)
+    def []= x, y, color
       raise "bad x value #{x} >= #{@width}" if x >= @width
       raise "bad y value #{y} >= #{@height}"  if y >= @height
+      raise "bad color #{color.inspect}" unless color.kind_of? PNG::Color
       @data[@height-y-1][x] = color
     end
 
+    ##
+    # Composites another canvas onto self at the given (bottom left) coordinates.
+
+    def composite canvas, x, y, style = :overwrite
+      canvas.each do |x1, y1, color|
+        case style
+        when :overwrite then
+          self[x+x1, y+y1] = color
+        when :add, :underlay then
+          self[x+x1, y+y1] = self[x+x1, y+y1] | color
+        when :overlay then
+          self[x+x1, y+y1] = color | self[x+x1, y+y1]
+        when :blend then
+          self.point x+x1, y+y1, color
+        else
+          raise "unknown style for composite: #{style.inspect}"
+        end
+      end
+    end
+
+    ##
+    # Iterates over the canvas yielding x, y, and color.
+
+    def each
+      data.reverse.each_with_index do |row, y|
+        row.each_with_index do |color, x|
+          yield x, y, color
+        end
+      end
+    end
+
+    ##
+    # Create a new canvas copying a region of the current canvas
+
+    def extract x0, y0, x1, y1
+      canvas = Canvas.new(x1-x0+1, y1-y0+1)
+
+      (x0..x1).each_with_index do |x2, x3|
+        (y0..y1).each_with_index do |y2, y3|
+          canvas[x3, y3] = self[x2, y2]
+        end
+      end
+
+      canvas
+    end
+
     def inspect # :nodoc:
       '#<%s %dx%d>' % [self.class, @width, @height]
     end
@@ -512,5 +582,5 @@ class PNG
 
       return image.join
     end
-  end
+  end # Canvas
 end