pixelflut 0.0.13 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46bc6d8430a0a37a766f925558d1279fbf69457f859f9f6286c2fb4a3f3a9e81
-  data.tar.gz: f634ffe53ec48385c8c9b42f032f3fa0e56d91155cf075a05b2b9c15794d8dbb
+  metadata.gz: a4b1d4d4f5be08766e694539cf82507427f901f71ae1ec4c5568cec7344d1345
+  data.tar.gz: 65d9ebde1aa48a5989c28340d3da137b8d99d3952a85fbfb904ad7af64420df8
 SHA512:
-  metadata.gz: 53bb74856603e0d46563b707726cdb8d5d96f5192ebd641c00ebba463e45ba5165536f4b95ea60d28e0468f8735acb32d3439802541791faf9a2dcbe13b94dab
-  data.tar.gz: 2f26150a3d40045e6030018cbcbf807dcbb1f415f193f156d1c45d8c4eea5e5c6d56e5205d764b701b6d644346d0892042f5fb1cdd9ce0d9cd6ee5ba4fbad099
+  metadata.gz: 377feb36cdde2221e3d6c7739acc9773d771d15cf319e93e379c6f86248189c286af91a25e13acda88fc40e030b956761ffa205215e4bb37ddd9ee64e805e748
+  data.tar.gz: 910cd772cedf70ddd4cb01445821ccf360f54d96a3c4076b9845886a0e5e1a232a0b153e640b574e6540c490c77691bd515a6b42bb74ade60f0970e2e201c9f9

data/.gitignore

@@ -1,4 +1,3 @@
-_local/
 tmp/
 pkg/
 gems.locked

data/README.md

@@ -1,14 +1,12 @@
 # Pixelflut
 
-A Pixelflut server & client tool collection written in Ruby.
+A Pixelflut client written in Ruby.
 
 ## Description
 
-Based on the idea of a simple server protocol to collaborate on a shared canvas named [Pixel Flut](https://cccgoe.de/wiki/Pixelflut) this gem implements a Ruby version.
+Based on the idea of a simple server protocol to collaborate on a shared canvas named [Pixelflut](https://cccgoe.de/wiki/Pixelflut) this gem implements a Ruby version of a client.
 
-This gem is an open experiment to write a fast server and canvas in Ruby. You are welcome to fork or create pull requests to find the fastest solution!
-
-The gem includes some tools to develop Pixelflut clients and pre-processors.
+This gem is an open experiment. You are welcome to fork or create pull requests to find the fastest solution!
 
 ### Installation
 
@@ -26,76 +24,16 @@ You'll find some help on the command line:
 
 ```bash
 $ pxf
-usage: pxf command [options]
-
-valid commands:
-convert    Convert given IMAGE file to Pixelflut ASCII format.
-generate   Execute given generator FILEs.
-help       Print help for given COMMAND.
-send       Send given Pixelflut ASCII file to a server.
-server     Start Pixelflut server.
-version    Print version information.
-```
-
-### Start a Sserver
-
-Starting the server on default port `1234` and open a drawing screen is quite simple:
-
-```bash
-$ pxf server
-```
-
-With these options you can configure the server:
-
-```
--b, --bind ADDR          bind to given address
--p, --port PORT          select port(default: 1234)
--k, --keep-alive         set maximum keep-alive time
--r, --read_buffer SIZE   set read buffer size (default: 1024)
--w, --width WIDTH        set canvas width (default: 800)
--h, --height HEIGHT      set canvas height (default: 600)
--f, --[no-]fullscreen    run in fullscreen mode
+Usage: pxf [OPTIONS] IMAGE
+
+Options:
+    --host ADDRESS        target host address
+-p, --port PORT           target port (default 1234)
+-c, --connections CONN    count of connections (default 4)
+-b, --bytes BYTES         send junks of BYTES size
+-x, --transpose-x X       transpose image X pixels
+-y, --transpose-y Y       transpose image Y pixels
+-s, --scale SCALE         scale image by SCALE factor
+-m, --pixel MODE          select pixel coding (RGBX | RGBA | RGB)
+-h, --help                print this help
 ```
-
-### Convert an Image
-
-There is a conversion command which can be used to convert a given image to the Pixelflut ASCII text format:
-
-```bash
-$ pxf convert image.png
-```
-
-The result can send directly to a server (sample assumes the server runs on localhost port 1234):
-
-```bash
-$ pxf convert image.png | pxf send
-```
-
-The converter can help you to resize and positioning the image at the servers canvas. These options are avail:
-
-```
--x, --transpose-x X   transpose image X pixels
--y, --transpose-y Y   transpose image Y pixels
--w, --width WIDTH     resize the image to given WIDTH
--h, --height HEIGHT   resize the image to given HEIGHT
-```
-
-It maybe faster to pre-process your images and send them later:
-
-```bash
-$ pxf convert -x 50 -y 100 --width 100 image1.png > image1.px
-$ pxf convert -x 150 --width 2100 image2.png > image2.px
-$ pxf send -h pixel_host image1.px image2.px
-```
-
-### Send Pixelflut ASCII Text
-
-The `pxf send` command can be used to send given Pixelflut ASCII text files to a server. It uses several connections at the same time to fasten the transmission.
-
-Next sample will send the Pixelflut ASCII text file named `pixels.px` to the server on port 1234 at address `pixelhost` using 12 connections:
-
-```bash
-$ pxf send -h pixelhost -p 1234 -c 12 pixels.px
-```
-
-If no file is given the STDIN will be read and send afterwards to the server.

data/bin/pxf

@@ -1,33 +1,69 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-def bin_root
-  File.realdirpath('../', __FILE__).freeze
+help <<~end, 'IMAGE'
+      --host ADDRESS        target host address
+  -p, --port PORT           target port (default 1234)
+  -c, --connections CONN    count of connections (default 4)
+  -b, --bytes BYTES         send junks of BYTES size
+  -x, --transpose-x X       transpose image X pixels
+  -y, --transpose-y Y       transpose image Y pixels
+  -s, --scale SCALE         scale image by SCALE factor
+  -m, --pixel MODE          select pixel coding (RGBX | RGBA | RGB)
+  -h, --help                print this help
 end
 
-def find_commands
-  Hash[Dir.glob(File.join(bin_root, 'pxf-*')).map!{ |cmd| [File.basename(cmd)[4..-1], cmd] }]
+main do |opts|
+  data = create_junks(opts)
+  print("spawn #{data.size}")
+  data.size.times do |i|
+    next unless fork
+    Process.setproctitle(name(format("#{name}-%02d", i + 1)))
+    data = data[i].join
+    GC.start
+    GC.disable
+    Pixelflut::Sender.send(opts.address, data) { print('.') }
+  end
+rescue SocketError => e
+  error(3, e)
+rescue LoadError => e
+  error(4, e)
+rescue Errno::ECONNREFUSED
+  error(2, 'unable to connect')
+rescue Errno::EPIPE
+  error(2, 'connection lost')
 end
 
-def err(msg)
-  $stderr.puts("pxf: #{msg}")
-  exit 1
+def create_junks(opts)
+  lines = Pixelflut.convert(**opts.to_h)
+  return Pixelflut.slices(lines, count: opts.count) if opts.bytes.zero?
+  Pixelflut.junks(lines, bytes: opts.bytes)
 end
 
-def general_help
-  puts('usage: pxf command [options]', nil, 'valid commands:')
-  map = find_commands.transform_values!{ |cmd| %x(#{cmd} --short-help) }
-  cmds = map.keys.sort!
-  len = cmds.max_by(&:size).size + 3
-  cmds.each do |cmd|
-    print cmd.ljust(len)
-    puts(map[cmd])
-  end
-  exit
+before do
+  $stderr.sync = $stdout.sync = true
+  Process.setproctitle(name)
+  require_relative('../lib/pixelflut')
+end
+
+parse_argv do |args|
+  Struct.new(:address, :count, :bytes, :x, :y, :mode, :scale, :source) do
+    def to_h
+      { source: source, x: x, y: y, scale: scale, mode: mode }
+    end
+  end.new(
+    Pixelflut::Sender.address(
+      args['ADDRESS'] || '127.0.0.1',
+      (args['PORT'] || 1234).to_i
+    ),
+    (args['CONN'] || 4).to_i,
+    args['BYTES'].to_i,
+    args['X'].to_i,
+    args['Y'].to_i,
+    { 'RGBA' => :rgba, 'RGB' => :rgb }[args['MODE']] || :rgbx,
+    args.key?('SCALE') ? args['SCALE'].to_f : nil,
+    args['IMAGE']
+  )
 end
 
-general_help if ARGV.empty? || ARGV[0] == '--help' || ARGV[0] == '-h'
-cmd = ARGV.shift
-fname = File.join(bin_root, 'pxf-' + cmd)
-err("no such command - #{cmd}") unless File.executable?(fname)
-exec(fname, *ARGV)
+BEGIN { require('mini-cli') and include(MiniCli) }

data/bin/pxf-info

@@ -1,55 +1,32 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
+#! /bin/sh
 
-def options(cfg)
-  require 'optparse'
-  OptionParser.new do |opts|
-    opts.summary_indent = '  '
-    opts.banner = 'usage: pxf info [options]'
-    opts.separator(nil)
-    opts.separator('valid options:')
-    opts.on('-h', '--host HOST', String, 'target host name (default localhost)'){ |v| cfg[:host] = v }
-    opts.on('-p', '--port PORT', Integer, 'target port (default 1234)'){ |v| cfg[:port] = v }
-  end
-end
+set -e
 
-def help(short)
-  puts(options(nil), nil) unless short
-  puts('Get info about a Pixelflut server.')
-  exit
-end
+if [ "$1" = '--help' ]
+then
+  echo "Usage: ${0##*/} [-p|--port PORT] ADDRESS
 
-def err(msg, code = 1)
-  $stderr.puts("pxf: #{msg}")
-  exit(code)
-end
+Requests screen size of Pixelflut server at ADDRESS.
+"
+  exit 0
+fi
 
-def create_options
-  {port: 1234}.tap{ |cfg| options(cfg).parse! }
-rescue OptionParser::ParseError => e
-  err(e)
-end
+PORT="1234"
+ADDRESS=""
 
-help(false) if '--help' == ARGV[0]
-help(true) if '--short-help' == ARGV[0]
-options = create_options
-require File.realdirpath('../../lib/pixelflut/client/socket.rb', __FILE__)
-begin
-  socket = Pixelflut::Client::Socket.new(Addrinfo.tcp(options[:host], options[:port]))
+while [ $# -gt 0 ]
+do
+  key="$1"
+  case $key in
+  -p|--port)
+    PORT="$2"
+    shift; shift
+    ;;
+  *)
+    ADDRESS="$key"
+    shift
+    ;;
+  esac
+done
 
-
-  err("unable to connect - #{options[:host]}:options[:port])", 2) unless socket.connect? || socket.wait_writable(5)
-  err("server busy - #{options[:host]}:options[:port])", 3) unless socket.write_with_timout("SIZE\n", 5)
-  line = socket.readline_with_timeout(5)
-  socket.close
-  err("server does not respond - #{options[:host]}:options[:port])", 4) unless line
-  mark, width, height = line.split(' ', 3)
-  width = width.to_i
-  height = height.to_i
-  err("no Pixelflut server - #{options[:host]}:options[:port])", 5) if mark != 'SIZE' || width <= 0 || height <= 0
-  puts "canvas size: #{width}x#{height}"
-rescue SocketError, SystemCallError => e
-  err(e.message, 2)
-rescue Interrupt
-  exit
-end
+echo "SIZE\nQUIT\n" | nc "$ADDRESS" "$PORT"

data/gems.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-source('https://rubygems.org'){ gemspec }
+source('https://rubygems.org') { gemspec }

data/lib/pixelflut.rb

@@ -1,8 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'pixelflut/image'
+require_relative 'pixelflut/sender'
+
 module Pixelflut
-  LIB_DIR = File.realdirpath('../pixelflut', __FILE__).freeze
-  autoload :App, File.join(LIB_DIR, 'app.rb')
-  autoload :Server, File.join(LIB_DIR, 'server.rb')
-  autoload :Canvas, File.join(LIB_DIR, 'canvas.rb')
-  autoload :Converter, File.join(LIB_DIR, 'converter.rb')
-  autoload :VERSION, File.join(LIB_DIR, 'version.rb')
+  class << self
+    def convert(source:, x: 0, y: 0, scale: nil, mode: :rgbx)
+      _convert(as_image(source, scale), x, y, &as_cvt(mode))
+    end
+
+    def slices(lines, count: 4)
+      Array.new(count) { [] }.tap do |ret|
+        lines.each_with_index { |line, idx| ret[idx % count] << line }
+      end
+    end
+
+    def junks(lines, bytes:)
+      size, ret = 0, [current = []]
+      lines.each do |line|
+        next current << line if (size += line.bytesize) < bytes
+        ret << (current = [line])
+        size = line.bytesize
+      end
+      ret
+    end
+    alias packages junks # backward compatibility
+
+    private
+
+    def _convert(image, dx, dy)
+      image.each_pixel.to_a.map! do |x, y, px|
+        "PX #{x + dx} #{y + dy} #{yield(px)}\n"
+      end.shuffle!
+    end
+
+    def as_image(source, scale)
+      Image.new(source).tap { |image| image.scale(scale) if scale }
+    end
+
+    def as_cvt(mode)
+      case mode
+      when :rgb
+        lambda { |px| px.to_color(Magick::AllCompliance, false, 8, true)[1, 6] }
+      when :rgba
+        lambda { |px| px.to_color(Magick::AllCompliance, true, 8, true)[1, 8] }
+      else
+        lambda do |px|
+          px.to_color(Magick::AllCompliance, false, 8, true)[
+            1,
+            px.alpha >= 65_535 ? 6 : 8
+          ]
+        end
+      end
+    end
+  end
 end

data/lib/pixelflut/image.rb

@@ -0,0 +1,32 @@
+require 'rmagick'
+
+module Pixelflut
+  class Image
+    def initialize(file_name)
+      @image = Magick::ImageList.new(file_name)[0]
+    rescue Magick::ImageMagickError => e
+      raise(LoadError, e.message, cause: e)
+    end
+
+    def width
+      @image.columns
+    end
+
+    def height
+      @image.rows
+    end
+
+    def resize_to(width, height = nil)
+      @image.resize_to_fit!(width, height)
+    end
+
+    def scale(factor)
+      @image.scale!(factor)
+    end
+
+    def each_pixel
+      return to_enum(__method__) unless block_given?
+      @image.each_pixel { |px, x, y| 0 != px.alpha and yield(x, y, px) }
+    end
+  end
+end

data/lib/pixelflut/sender.rb

@@ -0,0 +1,29 @@
+require 'socket'
+
+module Pixelflut
+  module Sender
+    def self.address(host, port)
+      Addrinfo.tcp(host, port)
+    end
+
+    def self.send(address, data)
+      socket = create_socket(address)
+      yield(socket) if block_given?
+      loop { socket.write(data) }
+    end
+
+    def self.create_socket(address)
+      Socket
+        .new(address.ipv6? ? :INET6 : :INET, :STREAM)
+        .tap do |socket|
+          socket.sync = false
+          socket.setsockopt(:TCP, :NODELAY, 0)
+          socket.setsockopt(:SOCKET, :KEEPALIVE, 0)
+          socket.do_not_reverse_lookup = true
+          socket.connect(
+            Socket.pack_sockaddr_in(address.ip_port, address.ip_address)
+          )
+        end
+    end
+  end
+end

data/lib/pixelflut/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pixelflut
-  VERSION = '0.0.13'.freeze
+  VERSION = '0.2.1'
 end

data/pixelflut.gemspec

@@ -2,40 +2,33 @@
 
 require_relative 'lib/pixelflut/version'
 
-GemSpec = Gem::Specification.new do |spec|
+Gem::Specification.new do |spec|
   spec.name = 'pixelflut'
   spec.version = Pixelflut::VERSION
-  spec.summary = 'A Pixelflut server & client tool collection written in Ruby.'
+  spec.author = 'Mike Blumtritt'
+
+  spec.required_ruby_version = '>= 2.7.2'
+
+  spec.summary = 'A fast Pixelflut client written in Ruby.'
   spec.description = <<~DESCRIPTION
-    Based on the idea of a simple server protocol to collaborate on a shared canvas named
-    [Pixel Flut](https://cccgoe.de/wiki/Pixelflut) this gem implements a Ruby version.
+    Based on the idea of a simple server protocol to collaborate on a shared
+    canvas named [Pixelflut](https://cccgoe.de/wiki/Pixelflut) this gem
+    implements a fast Ruby client version.
   DESCRIPTION
-  spec.author = 'Mike Blumtritt'
-  spec.email = 'mike.blumtritt@invision.de'
   spec.homepage = 'https://github.com/mblumtritt/pixelflut'
-  spec.metadata = {
-    'issue_tracker' => 'https://github.com/mblumtritt/pixelflut/issues'
-  }
-  spec.rubyforge_project = spec.name
 
-  spec.add_runtime_dependency 'gosu', '>= 0.13.2'
-  spec.add_development_dependency 'bundler', '>= 1.16.0'
-  spec.add_development_dependency 'rake', '>= 12.3.0'
+  spec.metadata['source_code_uri'] = 'https://github.com/mblumtritt/pixelflut'
+  spec.metadata['bug_tracker_uri'] =
+    'https://github.com/mblumtritt/pixelflut/issues'
 
-  spec.platform = Gem::Platform::RUBY
-  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-  spec.required_ruby_version = '>= 2.5.0'
+  spec.add_runtime_dependency 'rmagick'
+  spec.add_runtime_dependency 'mini-cli', '>= 0.4.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
 
-  spec.require_paths = %w[lib]
   spec.bindir = 'bin'
-  spec.executables =
-    Dir
-    .glob(File.expand_path('../bin/*', __FILE__))
-    .map!{ |fn| File.basename(fn) }
-
-  all_files = %x(git ls-files -z).split(0.chr)
-  spec.test_files = all_files.grep(%r{^(spec|test)/})
-  spec.files = all_files - spec.test_files
+  spec.executables = %w[pxf pxf-info]
 
+  spec.files = Dir.chdir(__dir__) { `git ls-files -z`.split(0.chr) }
   spec.extra_rdoc_files = %w[README.md]
 end