rixmap 0.1.0

data/lib/rixmap/format/pcx.rb

@@ -0,0 +1,438 @@
+# -*- coding: utf-8 -*-
+
+#
+module Rixmap
+  module Format
+
+    # PCX画像形式用入出力実装モジュール.
+    module PCX
+
+      # PCXファイルシグネチャバイト
+      FILE_SIGNATURE = 0x0A
+
+      # パレットセパレータバイト
+      PALETTE_SEPARATOR = 0x0C
+
+      # Version 2.5 with fixed EGA Palette information
+      FORMAT_VERSION_25 = 0x00
+
+      # Version 2.8 with modifiable EGA palette information
+      FORMAT_VERSION_28_PLT = 0x02
+
+      # Version 2.8 without palette information
+      FORMAT_VERSION_28_NOPLT = 0x03
+
+      # PC Paintbrush for Windows
+      FORMAT_VERSION_PC_WINDOWS = 0x04
+
+      # Version 3.0
+      FORMAT_VERSION_30 = 0x05
+
+      # RGB or パレット形式定数
+      COLORTYPE_NORMAL = 0x01
+
+      # グレースケール形式
+      COLORTYPE_GRAYSCALE = 0x02
+
+      # 無圧縮形式
+      ENCODINGTYPE_NONE = 0x00
+
+      # RLE圧縮
+      ENCODINGTYPE_RLE = 0x01
+
+      # PCXファイルヘッダ.
+      class PCXFileHeader
+        attr_accessor :magic
+        attr_accessor :version
+        attr_accessor :encoding
+        attr_accessor :bit_width
+
+        attr_accessor :left
+        attr_accessor :top
+        attr_accessor :right
+        attr_accessor :bottom
+
+        attr_accessor :dpi_x
+        attr_accessor :dpi_y
+
+        attr_accessor :palette
+
+        attr_accessor :bit_planes
+        attr_accessor :line_width
+        attr_accessor :colortype
+
+        attr_accessor :screen_x
+        attr_accessor :screen_y
+
+        def initialize()
+          @magic = FILE_SIGNATURE
+          @version = FORMAT_VERSION_30
+          @encoding = ENCODINGTYPE_RLE
+          @bit_width = nil
+          @left = nil
+          @top = nil
+          @right = nil
+          @bottom = nil
+          @dpi_x = 72
+          @dpi_y = 72
+          @palette = "\x00" * 48
+          @bit_planes = nil
+          @line_width = nil
+          @colortype = COLORTYPE_NORMAL
+          @screen_x = 0
+          @screen_y = 0
+
+          # packデータ
+          @template = "CCCCssssssa48xCSSssx54"
+        end
+
+        def unpack(data)
+          @magic, @version, @encoding, @bit_width, @left, @top, @right, @bottom, @dpi_x, @dpi_y, @palette, @bit_planes, @line_width, @colortype, @screen_x, @screen_y = data.unpack(@template)
+        end
+
+        def pack()
+          return [@magic, @version, @encoding, @bit_width, @left, @top, @right, @bottom, @dpi_x, @dpi_y, @palette, @bit_planes, @line_width, @colortype, @screen_x, @screen_y].pack(@template)
+        end
+      end
+
+      # RLEエンコーダ
+      class RLE
+        # パケットを構築します.
+        #
+        # @param [Integer] byte バイトデータ
+        # @param [Integer] count バイトデータの数
+        # @return [Array<Integer>] パケットデータ
+        def pack(byte, count)
+          cnt = count / 0x3F
+          rem = count % 0x3F
+          packed = [0xFF, byte] * cnt
+          if rem > 0
+            if byte < 0xC0 && rem == 1
+              packed.concat([byte])
+            else
+              packed.concat([0xC0 | rem, byte])
+            end
+          end
+          return packed
+        end
+
+        # バイト列をRLEによって圧縮します.
+        #
+        # @param [Array<Integer>] bytes バイト列
+        # @return [Array<Integer>] 圧縮されたバイト列
+        def encode(bytes)
+          return [] if bytes.empty?
+          data = []
+          byte0 = bytes[0]
+          count = 1
+          (1...bytes.size).each do |i|
+            byte = bytes[i]
+            if byte0 == byte
+              count += 1
+            else
+              data.concat(self.pack(byte0, count))
+              byte0 = byte
+              count = 1
+            end
+          end
+          if count > 0
+            data.concat(self.pack(byte0, count))
+          end
+          return data
+        end
+
+        # バイト列をRLEとして復元します.
+        #
+        # @param [Array<Integer>] bytes バイト列データ
+        # @param [Integer] total 最大復元バイト長
+        # @return [Array] 復元されたバイト列データ (整数配列) と、入力バイト列のどこまでを解析したかのオフセット
+        # @example 例えばこんな感じになります (データは適当)
+        #   bytes = [0, 0, 0, 0, 0, ...]
+        #   data, offset = rle.decode(bytes, 5)
+        #   p data    #=> [0, 0, 0, 0, 0]
+        #   p offset  #=> 3
+        def decode(bytes, total)
+          data   = []
+          offset = 0
+          length = bytes.length
+          count  = 0
+
+          while offset < length && count < total
+            byte0 = bytes[offset]
+            offset += 1
+            if byte0 >= 0xC0    # RLEパケット
+              cnt = byte0 & 0x3F
+              byte1 = bytes[offset]
+              offset += 1
+              data.concat([byte1] * cnt)
+              count += cnt
+            else                # 生データ
+              data.push(byte0); count += 1
+            end
+          end
+
+          return [data, offset]
+        end
+      end
+
+      # PCX画像入出力処理実装.
+      class PCXImageIO < Rixmap::ImageIO::BaseImageIO
+        # 指定データがPCXとして読み込めるデータかどうかを調べます.
+        #
+        # @param [String] magic 画像の先頭データ
+        # @return [Boolean] PCXとして読み込める場合はtrue
+        def self.readable?(magic)
+          return magic[0].ord == FILE_SIGNATURE && magic[1].ord == FORMAT_VERSION_30
+        end
+
+        # 指定画像がPCXとして書き込めるかどうかを判定します.
+        #
+        # 実は透明度付のPCX画像はサポートしてなかったりします.
+        # 書き込み処理は実行できますが、その場合は透明度を無視して
+        # 書き込むようになってます.
+        #
+        # @param [Rixmap::Image] image 調べる画像
+        # @return [Boolean] PCXとして書き込める場合はtrue
+        def self.writable?(image)
+          if image.has_alpha?
+            return false
+          else
+            return true
+          end
+        end
+
+        # PCX入出力オブジェクトを初期化します.
+        #
+        # @param [Hash] options オプションパラメータ
+        # @option options [Boolean] :compression 圧縮するかどうか (Default: true)
+        def initialize(options={})
+          super(options)
+
+          @compression = true unless defined?(@compression)
+        end
+
+        # PCX形式として画像をエンコードします.
+        #
+        # @param [Rixmap::Image] image 対象画像
+        # @param [Hash] options オプションパラメータ
+        # @option options [Boolean] :compression 圧縮するかどうか (Defalt: true)
+        # @return [String] 画像データバイト列
+        def encode(image, options={})
+          # 圧縮フラグを取得
+          compression = if options[:compression].nil?
+                          @compression
+                        else
+                          options[:compression]
+                        end
+
+          # ヘッダを構築 (共通部分)
+          header = PCXFileHeader.new
+          header.left   = 0
+          header.top    = 0
+          header.right  = image.width - 1
+          header.bottom = image.height - 1
+          header.encoding = if compression
+                              ENCODINGTYPE_RLE
+                            else
+                              ENCODINGTYPE_NONE
+                            end
+          header.line_width = image.width
+          header.bit_width  = 8
+
+          # ピクセルデータ置場
+          pixels = Array.new
+
+          # エンコーダ
+          rle = RLE.new
+
+          # 各形式での処理
+          if image.indexed?       # インデックスカラー形式
+            header.colortype = COLORTYPE_NORMAL
+            header.bit_planes = 1
+
+            # ピクセルの結合
+            if compression
+              # RLE
+              image.each_line do |line|
+                pixels.concat(rle.encode(line.palette))
+              end
+            else
+              # 無圧縮ピクセルデータ
+              image.each_line do |line|
+                pixels.concat(line.palette)
+              end
+            end
+          elsif image.grayscale?  # グレースケール形式
+            header.colortype = COLORTYPE_GRAYSCALE
+
+            # 透明度は無視
+            header.bit_planes = 1
+
+            # ピクセルの結合
+            if compression
+              # RLE
+              image.each_line do |line|
+                pixels.concat(rle.encode(line.luminance))
+              end
+            else
+              # 無圧縮
+              image.each_line do |line|
+                pixels.concat(line.luminance)
+              end
+            end
+          elsif image.rgb?        # RGBカラー形式
+            header.colortype = COLORTYPE_NORMAL
+
+            # 透明度は無視
+            header.bit_planes = 3
+
+            # ピクセルの結合
+            if compression
+              # RLE
+              image.each_line do |line|
+                pixels.concat(rle.encode(line.red))
+                pixels.concat(rle.encode(line.green))
+                pixels.concat(rle.encode(line.blue))
+              end
+            else
+              # 無圧縮
+              image.each_line do |line|
+                pixels.concat(line.red)
+                pixels.concat(line.green)
+                pixels.concat(line.blue)
+              end
+            end
+          end
+
+          # 結合
+          data = header.pack() + pixels.pack('C*')
+          if image.indexed? && !image.palette.nil?
+            data.concat("\x0C")
+            data.concat(image.palette.to_s('RGB'))
+          end
+
+          return data
+        end
+
+        # バイト列をPCXデータとして復元します.
+        #
+        # @param [String] data バイト列
+        # @param [Hash] options オプションパラメータ (現在未実装)
+        # @return [Rixmap::Image] 復元された画像
+        def decode(data, options={})
+          header_data = data.byteslice(0, 128)
+          image_data  = data.byteslice(128, (data.bytesize - 128)).unpack('C*')
+
+          # ヘッダを再構築
+          header = PCXFileHeader.new
+          header.unpack(header_data)
+
+          # ヘッダを確認
+          unless header.magic == FILE_SIGNATURE
+            raise ArgumentError.new("Input data is not PCX image data")
+          end
+          unless header.version == FORMAT_VERSION_30
+            raise NotImplementedError.new("Currently supported only PCX Version 3.0, yet")
+          end
+          unless header.encoding == ENCODINGTYPE_NONE || header.encoding == ENCODINGTYPE_RLE
+            raise ArgumentError.new("Unknown encoding-type: #{header.encoding}")
+          end
+          unless header.colortype == COLORTYPE_NORMAL || header.colortype == COLORTYPE_GRAYSCALE
+            raise ArgumentError.new("Unknown color-type: #{header.colortype}")
+          end
+          unless header.bit_width == 8
+            raise NotImplementedError.new("Currently supported only 8-bit image")
+          end
+          if header.bit_planes < 1
+            raise ArgumentError.new("Input image has no pixel data")
+          end
+
+          # 画像を復元
+          image = nil
+          imwidth  = header.right - header.left + 1
+          imheight = header.bottom - header.top + 1
+          total_bytes = header.line_width * header.bit_planes * imheight
+
+          # ピクセルデータを復元
+          pixels = nil
+          pixel_end_offset = nil
+          if header.encoding == ENCODINGTYPE_RLE
+            rle = RLE.new
+            pixels, pixel_end_offset = rle.decode(image_data, total_bytes)
+          else
+            pixels = image_data.slice(0, total_bytes)
+            pixel_end_offset = total_bytes
+          end
+
+          # まずはカラータイプで分岐
+          if header.colortype == COLORTYPE_GRAYSCALE  # グレースケール
+            image = Rixmap::Image.new(Rixmap::GRAYSCALE, imwidth, imheight)
+            if header.bit_planes > 1    # 輝度値 + 謎プレーン
+              pixels.each_slice(header.line_width * header.bit_planes).each_with_index do |line, i|
+                break if i >= imheight
+                image[h].luminance = line.slice(0, imwidth)
+              end
+            else                        # 輝度値
+              pixels.each_slice(header.line_width).each_with_index do |line, i|
+                break if i >= imheight
+                image[i].luminance = line
+              end
+            end
+          else                                        # カラー形式
+            if header.bit_planes > 3      # RGB + 謎プレーン
+              image = Rixmap::Image.new(Rixmap::RGB, imwidth, imheight)
+              roffset = 0
+              goffset = header.line_width
+              boffset = header.line_width * 2
+              pixels.each_slice(header.line_width * header.bit_planes).each_with_index do |line, i|
+                break if i >= imheight
+                image[i].red   = line.slice(roffset, imwidth)
+                image[i].green = line.slice(goffset, imwidth)
+                image[i].blue  = line.slice(boffset, imwidth)
+              end
+            elsif header.bit_planes == 3  # RGB
+              image = Rixmap::Image.new(Rixmap::RGB, imwidth, imheight)
+              roffset = 0
+              goffset = header.line_width
+              boffset = header.line_width * 2
+              pixels.each_slice(header.line_width * 3).each_with_index do |line, i|
+                break if i >= imheight
+                image[i].red   = line.slice(roffset, imwidth)
+                image[i].green = line.slice(goffset, imwidth)
+                image[i].blue  = line.slice(boffset, imwidth)
+              end
+            elsif header.bit_planes == 1  # INDEXED
+              image = Rixmap::Image.new(Rixmap::INDEXED, imwidth, imheight)
+              pixels.each_slice(header.line_width).each_with_index do |line, i|
+                break if i >= image.height
+                image[i].palette = line
+              end
+
+              if pixel_end_offset < image_data.length && image_data[pixel_end_offset] == PALETTE_SEPARATOR && !image.palette.nil?
+                # パレットある
+                palette_data = image_data.slice(pixel_end_offset + 1, (image_data.length - (pixel_end_offset + 1)))
+                palette = image.palette
+                palette_data.each_slice(3).each_with_index do |color, i|
+                  break if i >= palette.size
+                  palette[i] = color
+                end
+              end
+            else                          # ！？
+              raise RuntimeError.new("Illegal bit-planes #{header.bit_planes}")
+            end
+          end
+
+          return image
+        end
+      end
+
+      Rixmap::ImageIO.register(:PCX, PCXImageIO, [".pcx"])
+    end
+
+  end
+end
+
+
+#==============================================================================#
+# $Id: pcx.rb,v 57b1fb2cd6a6 2014/04/20 12:21:27 chikuchikugonzalez $
+# vim: set sts=2 ts=2 sw=2 expandtab:

data/lib/rixmap/format/png/chunk.rb

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+
+#
+module Rixmap
+  module Format
+    module PNG
+
+      # PNGチャンクデータモジュール
+      module Chunk
+
+        # チャンクタイプ名と実装クラスの対応を登録します.
+        #
+        # @param [String] name チャンクタイプ名
+        # @param [Class] klass チャンク実装クラス
+        # @return [void]
+        def self.set(name, klass)
+          unless defined?(@chunks)
+            @chunks = Hash.new
+          end
+          @chunks[name] = klass
+        end
+
+        # チャンクタイプ名からその実装クラスを取得します.
+        #
+        # @param [String] name チャンクタイプ名
+        # @return [Class,nil] チャンク実装クラス. 未登録の場合はnil
+        def self.get(name)
+          unless defined?(@chunks)
+            @chunks = Hash.new
+          end
+          return @chunks[name]
+        end
+
+        # PNGチャンクベースクラス
+        class BaseChunk
+          # チャンクを初期化します.
+          #
+          # @param [String] type チャンクタイプ
+          # @param [String] data チャンクデータ
+          def initialize(type, data = nil)
+            @type = type
+            @data = nil
+
+            self.data = data unless data.nil?
+          end
+
+          # チャンクタイプを返します.
+          #
+          # @return [String] チャンクタイプ
+          def type()
+            return @type
+          end
+
+          # チャンクデータを返します.
+          #
+          # @return [String] チャンクデータ
+          def data()
+            self.pack()
+            return @data
+          end
+
+          # チャンクデータを更新します.
+          #
+          # @param [String] data チャンクデータ
+          def data=(data)
+            @data = data
+            self.unpack()
+            return nil
+          end
+
+          # 補助チャンクかどうかを返します.
+          #
+          # @return [Boolean] 補助チャンクならtrue
+          def optional?()
+            return (@type[0].ord & 0x20) != 0
+          end
+
+          # プライベートチャンクかどうかを返します.
+          #
+          # @return [Boolean] プライベートチャンクならtrue
+          def private?()
+            return (@type[1].ord & 0x20) != 0
+          end
+
+          # 標準チャンクかどうかを返します.
+          #
+          # @return [Boolean] 標準チャンクならtrue
+          def standard?()
+            return (@type[2].ord & 0x20) == 0
+          end
+
+          # コピー安全なチャンクかどうかを返します.
+          #
+          # @return [Boolean] コピー安全なチャンクならtrue
+          def copysafe?()
+            return (@type[3].ord & 0x20) != 0
+          end
+
+          # データ取得前の、データ構築処理を行います.
+          #
+          # #data から呼び出されます
+          def pack()
+          end
+          protected :pack
+
+          # データ更新後の、内部プロパティ更新処理を行います.
+          def unpack()
+          end
+          protected :unpack
+
+        end
+
+        # IHDRイメージヘッダチャンク.
+        class IHDRChunk < BaseChunk
+          # IHDRチャンクタイプ
+          TYPE   = "IHDR"
+
+          # pack用IHDRデータレイアウト
+          LAYOUT = "N2C5"
+
+          attr_accessor :width
+          attr_accessor :height
+          attr_accessor :depth
+          attr_accessor :colortype
+          attr_accessor :compress
+          attr_accessor :filter
+          attr_accessor :interlace
+
+          def initialize(width = 0, height = 0, depth = 0,
+                         colortype = COLORTYPE_TRUECOLOR,
+                         compress = COMPRESSION_DEFLATE,
+                         filter = FILTER_ADAPTIVE,
+                         interlace = INTERLACE_NONE)
+            @width     = width
+            @height    = height
+            @depth     = depth
+            @colortype = colortype
+            @compress  = compress
+            @filter    = filter
+            @interlace = interlace
+
+            super(IHDRChunk::TYPE)
+          end
+
+          def pack()
+            @data = [@width, @height, @depth, @colortype, @compress, @filter, @interlace].pack(IHDRChunk::LAYOUT)
+          end
+          protected :pack
+
+          def unpack()
+            @width, @height, @depth, @colortype, @compress, @filter, @interlace = @data.unpack(IHDRChunk::LAYOUT)
+          end
+          protected :unpack
+
+          # チャンクリストへ登録
+          Chunk.set(self::TYPE, self)
+        end
+
+        # PLTパレットチャンク
+        class PLTEChunk < BaseChunk
+          # PLTEチャンクタイプ
+          TYPE   = 'PLTE'
+
+          # pack用PLTEチャンクデータレイアウト
+          LAYOUT = 'C*'
+
+          def initialize()
+            @colors = []
+            super(PLTEChunk::TYPE)
+          end
+
+          # 指定番号のカラーデータ (3バイト) を取得します.
+          #
+          # データオフセットではなく、3バイトごとに区切られたカラーのオフセットであることに注意.
+          #
+          # @param [Integer] offset カラー番号
+          # @return [Array] RGBカラーデータ
+          def [](offset)
+            return @colors[offset * 3, 3]
+          end
+
+          # 指定番号のカラーデータを更新します.
+          #
+          # @param [Integer] offset カラー番号
+          # @param [Array] rgb カラーデータ
+          def []=(offset, rgb)
+            @colors[offset * 3, 3] = rgb
+          end
+
+          def pack()
+            @data = @colors.pack(PLTEChunk::LAYOUT)
+          end
+          protected :pack
+
+          def unpack()
+            @colors = @data.unpack(PLTEChunk::LAYOUT)
+          end
+          protected :unpack
+
+          # チャンクリストへ登録
+          Chunk.set(self::TYPE, self)
+        end
+
+        # IDATイメージデータチャンク
+        class IDATChunk < BaseChunk
+          # IDATチャンクタイプ
+          TYPE = 'IDAT'
+
+          def initialize()
+            super(IDATChunk::TYPE)
+          end
+
+          # チャンクリストへ登録
+          Chunk.set(self::TYPE, self)
+        end
+
+        # IENDイメージトレーラチャンク
+        class IENDChunk < BaseChunk
+          # IENDチャンクタイプ
+          TYPE = 'IEND'
+
+          def initialize()
+            super(IENDChunk::TYPE, '')
+          end
+
+          # チャンクリストへ登録
+          Chunk.set(self::TYPE, self)
+        end
+
+      end
+
+    end
+  end
+end
+
+
+#==============================================================================#
+# $Id: chunk.rb,v 57b1fb2cd6a6 2014/04/20 12:21:27 chikuchikugonzalez $
+# vim: set sts=2 ts=2 sw=2 expandtab: