pixel_raster 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c746ea24abf78533158d4767d3f034f4c4b37ab1
-  data.tar.gz: 30ada28f6043068d7338a8253f36e4230203b680
+SHA256:
+  metadata.gz: dd6246ac2fb2fc015e61ec280b5be406f2eade547be1dce4ced45dbd6120a208
+  data.tar.gz: 5a2adb8d02a378a963b52304556e6d5636625da5fb4599695c6bf7167c06b0d9
 SHA512:
-  metadata.gz: d306d952c1dc81df878e1e2f2ccca329db410c8d371d9445371f95e164fa1c0ad1d4890501c84a5ec2df42cd87197c6e2c0f1d97f64bb3c474c35da4afe65a75
-  data.tar.gz: 366517b49d2af18e08ea294eb84a89207aac6fceec89a7fc01ff70147c22dbf6b36f7b2842f0a63f7c3bf9a7244423bbf48ac5630385638c41aa7848e0d9aa54
+  metadata.gz: 9665873f9a4bfa9525f02a17bd0e2a910a07e26304e90d7ff7580be387a871f197ffa553eaecba4021a299c296264100dad4f59d0e9fd399568b700c07b0d6ae
+  data.tar.gz: c3f8038be85df22b0583f2ee63da7cb7589174ee2ae44506fdbefe47b51c7d76aaf68d5ef3d4e47b60f8803cd9f6a2d519b4452929ec6469aec1bf2b3a623453

data/README.md

@@ -21,6 +21,6 @@ paint-yourself raster versions (see [images.pdf](images.pdf)).
 ## xpm2tikz
 
 The script takes xpm images from the command line as input and
-outputs [tikz](https://ctan.org/pkg/pgf)-code to stdout.
+outputs [tikz](https://ctan.org/pkg/pgf) code to stdout.
 
 See `xpm2tikz -h`.

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/img2pixel

@@ -0,0 +1,6 @@
+#! /usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'img2pixel'
+
+PixelRaster::MagickConverter::command_line

data/lib/img2pixel.rb

@@ -0,0 +1,154 @@
+#! /usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'pixel_raster'
+require 'optparse'
+
+# Base module
+module PixelRaster
+  class MagickConverter
+
+    # Parse command line arguments (+ARGV+) and execute accordingly
+    #
+    # See +img2pixel -h+ for a list of options.
+    def self.command_line(argv=ARGV, stdout=$stdout, stderr=$stderr)
+      outfile = nil
+      outdir = nil
+      outmode = :both
+      empty_suffix = '-empty'
+      filled_suffix = '-filled'
+      params = {
+                type:     :svg,
+                bg_color: 'white'
+               }
+
+      if argv.length == 0 # no argument given
+        argv << '-h'      # give the help text
+      end
+      
+      begin
+        OptionParser.new do |p|
+          p.accept(Symbol) { |s| s.downcase.to_sym }
+          
+          p.banner = "Convert image(s) to a pixel representation."
+          
+          p.separator ""
+          p.separator "Usage: #{$0} [options] INFILE [INFILE…]"
+          p.separator ""
+          p.separator "For each INFILE two output files are written for the empty and filled version"
+          p.separator "(but see --mode)."
+          p.separator ""
+          p.separator "With “-O OUTFILE” all images are output to OUTFILE."
+          p.separator "Caveat: having several <svg>-elements concatenated in one file"
+          p.separator "may not be supported by your viewer."
+          p.separator ""
+          p.separator "Options:"
+          p.on_tail("-h", "--help", "Show this help message and exit.") do
+            stdout.puts p
+            exit
+          end
+          
+          p.on("-V", "--version", "Show version information and exit.") do
+            stdout.puts File.read(File.join(File.dirname(__FILE__),'..','VERSION'))
+            exit
+          end
+          
+          p.on('-O', '--output FILENAME',
+               'Write output to FILENAME (“-” for STDOUT).',
+               'If this option is given, all images',
+               'are written to the same file.',
+               'If this is given, “-d” is ignored.') do |filename|
+            outfile = filename
+          end
+          
+          p.on("-#", "--nr-of-colors N", Numeric,
+               "Number of colors for the final image.") do |n|
+            params[:nr_of_colors] = n
+          end
+
+          p.on('-c', '--bg-color COLOR',
+               "Background-color for empty version.",
+               "SVG color name. May be “none”.",
+               "Ignored for --type tikz.",
+               "Default: #{params[:bg_color]}") do |color|
+            params[:bg_color] = color
+          end
+          
+          p.on('-t', '--type TYPE', Symbol,
+               'The output type (svg or tikz).',
+               "Default: #{params[:type]}") do |type|
+            [:svg,:tikz].include?(type) or
+              p.abort("unknown output type #{type}")
+            params[:type] = type
+          end
+          
+          p.on('-m', '--mode MODE', Symbol,
+               'Output mode (both, empty, filled).',
+               "Default: #{outmode}") do |mode|
+            [:both,:empty,:filled].include?(mode) or
+              p.abort("unknown mode #{mode}")
+            outmode = mode
+          end
+
+          p.on('-l','--light2dark',
+               'color numbering direction.',
+               'Default: light2dark (unless 2 color imgs)') do
+            params[:light2dark] = true
+          end
+
+          p.on('-L','--dark2light',
+               'color numbering direction.',
+               'Default: light2dark (unless 2 color imgs)') do
+            params[:light2dark] = false
+          end
+
+          p.on('-d', '--dir DIR',
+               'directory for output files.',
+               'Must exist and be writeable.',
+               "Default: same as INFILE") do |dir|
+            outdir = dir
+          end
+        end.parse!(argv)
+      rescue OptionParser::ParseError => pe
+        stderr.puts pe
+        exit 22   # Errno::EINVAL::Errno (but may not exist on all platforms)
+      end
+
+
+      MagickConverter.new(**params) do |c|
+        if outfile == '-' # Write everything to standard out
+          argv.each do |infile|
+            stdout << c.convert(infile, mode: :empty)  unless outmode==:filled
+            stdout << c.convert(infile, mode: :filled) unless outmode==:empty
+          end
+        elsif outfile # an outfile is given, so write everything in this file
+          File.open(outfile, 'w') do |out|
+            argv.each do |infile|
+              out << c.convert(infile, mode: :empty)
+              out << c.convert(infile, mode: :filled)
+            end
+          end
+        else
+          argv.each do |infile|
+            # if no outfile is given we generate the filename from the infile
+            base_out = File.join(outdir || File.dirname(infile),
+                                 File.basename(infile, '.*'))
+
+            empty_out = base_out + empty_suffix + '.' + params[:type].to_s
+            filled_out = base_out + filled_suffix + '.' + params[:type].to_s
+            unless outmode==:filled
+              File.open(empty_out,"w") do |out|
+                out << c.convert(infile, mode: :empty)
+              end
+            end
+            unless outmode==:empty
+              File.open(filled_out,"w") do |out|
+                out << c.convert(infile, mode: :filled)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pixel_raster.rb

@@ -1,44 +1,185 @@
 #! /usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'rmagick'
 
 module PixelRaster
-  # read xpm files
-  # this is not very robust but assumes a straight forward file format
-  # without color/grayscale etc being mixed.
-  def read_xpm(filename)
-    lines = File.readlines(filename)
-    lines.shift # get rid of  /* XPM */
-    lines.shift # get rid of  static char * ...[] = {
-    meta = lines.shift.scan(/[0-9]+/)
-    n_x = meta[0].to_i
-    n_y = meta[1].to_i
-    n_of_colors = meta[2].to_i
-    n_of_chars = meta[3].to_i
-    
-    colors = {}
+  class MagickConverter
+
+    attr_reader :nr_of_colors, :bg_color, :resize, :light2dark, :type
+
+    # The converter is initialized with the constraints
+    # for the images to be processed.
+    #
+    # Any image must have a color index (palette), this is enforced.
+    # It is not that useful to have more than 10 colors or more than 30x30
+    # pixels, but this is only enforced if the corresponding parameters
+    # are given.
+    # @see #read_image
+    #
+    # @param nr_of_colors      maximum number of colors for the color index
+    # @param bg_color          background color for empty pixel image (svg)
+    # @param resize [String]   resize string (see ImageMagick resize option)
+    # @param light2dark [Boolean] if true 0 is the lightest color
+    # @param type [:svg|:tikz] 
+    def initialize(nr_of_colors: nil, bg_color: 'white',
+                   resize: nil, light2dark: nil,
+                   type: :svg)
+      @nr_of_colors = nr_of_colors
+      @bg_color = bg_color
+      @resize = resize
+      @light2dark = light2dark
+      @type = type
+      yield(self) if block_given?
+    end
     
-    n_of_colors.times do
-      lines.shift =~ /"(.{#{n_of_chars}})\s+([cgms]4?)\s+(.*?)"/
-      colors[$1] = $3
+    # Reads an image using RMagick and adjusts size and palette.
+    # As we need an indexed image we check and create one if neccessary.
+    #
+    # @see #initialize
+    # @param filename          read this file
+    # @return [Magick::Image] the (processed) image 
+    def read_image(filename)
+      # We assume each file includes exactly one image
+      image = Magick::Image.read(filename).first
+      
+      # on demand we resize the image
+      # the API is kinda complicated here:
+      # change_geometry computes the cols and rows from the given resize string
+      # and yields the given block with these values
+      if @resize
+        image.change_geometry(@resize) do |cols, rows, i|
+          image = i.resize!(cols, rows)
+        end
+      end
+      
+      # on demand we reduce the number of colors
+      if @nr_of_colors
+        image = image.quantize(@nr_of_colors)
+      else
+        # If the image does not have a palette/color index (and no number of
+        # columns was given) we create one with 2 colors. 
+        unless image.palette?
+          image = image.quantize(2)
+        end
+      end
+      # finally we remove duplicate colors.
+      image.compress_colormap!
+
+      return image
+    end
+
+    # Wrapper for the converter methods.
+    #
+    # @param mode [:empty|:filled] the output mode
+    # @param type [:svg|:tikz] the output type
+    # @see #image2tikz
+    # @see #image2svg
+    def convert(filename, mode:, type: @type)
+      img = read_image(filename)
+      case type
+      when :tikz
+        image2tikz(img, prefix: mode==:empty ? 'n' : 'y')
+      when :svg
+        image2svg(img, mode: mode)
+      else
+        raise "unknown output type #{type}"
+      end
     end
     
-    (1..n_y).collect do
-      lines.shift[1..n_x].scan(/.{#{n_of_chars}}/).collect { |c| colors[c] }
+    
+    # create a tikz pixel representation of an image.
+    #
+    # @param img [Magick::Image] the image
+    # @param prefix [String] node class prefix (to distinguish empty and filled mode)
+    def image2tikz(img, prefix: "n")
+      
+      colormap = compute_colormap(img)
+    
+      tikz = "  \\begin{tikzpicture}[yscale=-1]
+    \\draw[step=1,help lines] (0,0) grid (#{img.columns},#{img.rows});
+"
+      img.each_pixel do |p, c, r|
+        cc = colormap[p]
+        tikz << "    \\node[#{prefix}#{cc}] at (#{c+0.5},#{r+0.5}) {#{cc}};\n"
+      end
+      tikz << "
+  \\end{tikzpicture}
+
+"
+      tikz
+    end
+
+    # create a svg pixel representation of an image.
+    #
+    # @param img [Magick::Image] the image
+    # @param mode [:empty|:filled] fill mode
+    def image2svg(img, mode: :empty)
+      
+      colormap = compute_colormap(img)
+
+      # ToDo: make these flexible:
+      xw = 20
+      yh = 20
+      xwt = 10
+      yht = 15
+
+      # We create the SVG directly by string
+      svg = %Q'<svg xmlns="http://www.w3.org/2000/svg">
+   <style>
+     .pixel {
+       stroke : black;
+       stroke-width : 1;
+'
+      if mode == :empty
+        svg << "      
+       fill: #{@bg_color};
+"
+      end
+      svg << '
+     }
+'
+      if mode == :filled
+        colormap.each do |k,v|
+          color = k.to_color(Magick::AllCompliance,false, 8, true)
+          textcolor = k.to_hsla[2] > 50 ? 'black' : 'white'
+          svg << %Q{    .p#{v} { fill: #{color}; }\n}
+        
+          svg << %Q{    .t#{v} { fill: #{textcolor}; }\n}
+        end
+      end
+      svg << %Q{    </style>\n}
+      img.each_pixel do |p, c, r|
+        cc = colormap[p]
+        svg << %Q{  <rect x="#{c*xw}" y="#{r*yh}" width="#{xw}" height="#{yh}" class="pixel p#{cc}" />\n}
+        svg << %Q{  <text x="#{c*xw+xwt}" y="#{r*yh+yht}" text-anchor="middle" class="t#{cc}">#{cc}</text>\n}
+      end
+      svg << "</svg>\n"
+      svg
+    end
+
+    # compute an ordered colormap for the image
+    # @param img [Magick::Image] the image
+    # @param light2dark [Boolean] whether to invert the color map
+    def compute_colormap(img, light2dark: @light2dark)
+      # we create a colormap sorted from dark to light
+      colormap= {};
+      colors = img.color_histogram.map(&:first).sort_by(&:intensity)
+      # at least for a black and white image having 0 as white and
+      # 1 as black is more intuitive as you paint the pixels in black
+      # which are set. This is different from the common internal
+      # representation of images!
+      # We therefore assume light2dark _unless_ it's a 2-color image
+      # if it is not explicitely set:
+      light2dark = colors.length != 2 if light2dark.nil?
+      colors.reverse! if light2dark
+      colors.each_with_index do |p,i|
+        colormap[p]=i
+      end
+      return colormap
     end
-  end
-  
-  def xpm2tikz(filename, prefix="n")
-    xpm = read_xpm(filename)
-    "\\begin{tikzpicture}[yscale=-1]
-  \\draw[step=1,help lines] (0,0) grid (#{xpm.first.length},#{xpm.length});
-    " + xpm.each_with_index.collect { |row,r|
-      row.each_with_index.collect { |color,c|
-        cc = color=='#FFFFFF' ? '0' : '1'
-        "\\node[#{prefix+cc}] at (#{c+0.5},#{r+0.5}) {#{cc}};"
-      }.join("\n")
-    }.join("\n") + "
-\\end{tikzpicture}
-  "
   end
 end
 
+
   

metadata

@@ -1,28 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: pixel_raster
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Klaus Stein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-24 00:00:00.000000000 Z
-dependencies: []
+date: 2019-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: mititest-rg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Create a pixel raster representation of an image (for educational purposes).
 email: ruby@istik.de
 executables:
-- xpm2tikz
+- img2pixel
 extensions: []
 extra_rdoc_files: []
 files:
 - Beispiel.svg
 - LICENSE
 - README.md
-- bin/xpm2tikz
+- VERSION
+- bin/img2pixel
+- lib/img2pixel.rb
 - lib/pixel_raster.rb
-- lib/xpm2tikz.rb
 homepage: https://github.com/Lapizistik/pixel_raster
 licenses:
 - GPL-3.0
@@ -43,8 +72,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
-summary: Pixel image TikZ creator
+summary: Pixel image raster visualization
 test_files: []

data/bin/xpm2tikz

@@ -1,8 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: utf-8 -*-
-
-require 'xpm2tikz'
-
-include PixelRaster
-
-command_line

data/lib/xpm2tikz.rb

@@ -1,45 +0,0 @@
-#! /usr/bin/env ruby
-# -*- coding: utf-8 -*-
-
-require 'pixel_raster'
-require 'optparse'
-
-module PixelRaster
-
-  def command_line
-    out = $stdout
-    
-    OptionParser.new do |parser|
-      parser.banner = "\nConvert xpm image(s) to tikz. \n\nUsage: $0 [-O OUTFILE] INFILE [INFILE…]"
-
-      parser.on("-h", "--help", "Show this help message") do
-        puts parser
-        exit
-      end
-      
-      parser.on('-O', '--output FILENAME',
-                'write output to FILENAME (default: stdout)') do |filename|
-        begin
-          # We open the outfile here without ensuring it will be closed.
-          # This is ok as we need it throughout the whole script runtime
-          # and it will be closed on exit automatically.
-          out = File.open(filename, 'w')
-
-        # We could be more specific about catching errors, but we
-        # exit the script anyway, and this may be different on different OSes.
-        rescue StandardError => e
-          warn "Could not open “#{filename}” for writing."
-          warn e
-          exit e.errno
-        end
-      end
-    end.parse!
-
-    ARGV.each do |filename|
-      out << xpm2tikz(filename)
-      out << "\n\\vfill\n\n"
-      out << xpm2tikz(filename,'y')
-      out << "\n\\vfill\n\n"
-    end
-  end
-end