qttk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbc33230e89c5c92e9a6b609c0eea867988aa9b0c05a6943c5a2b0248e5bc1f5
+  data.tar.gz: 9a788b807af82292448b41513133f46895f13502b00de382087dbbc1d4492f04
+SHA512:
+  metadata.gz: e1df416f2c8704ab15cdfb4f841fe63ab44bf1e3f231fec6d9e1b052d2fed8b22650205dbc54b908f5be4f03df65113df27cd41e3b2ffcfeda6ec484f2ed97ef
+  data.tar.gz: 657245b02b29fea510973e769825e8e86b9540aada9ba795771c9ac97d619bfee8ad949bf0cb717a9a5c9bb5e669545f5f818e7e619483755c83db78a16fd059

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.gem

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'rake'
+
+# See .gemspec file for dependencies
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    qttk (0.1.0)
+      builder
+      cupsffi
+      descriptive_statistics
+      ffi
+      hashstruct
+      pathname3
+      rmagick
+      spliner
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.2.3)
+    cupsffi (0.1.7)
+      ffi
+    descriptive_statistics (2.5.1)
+    ffi (1.9.22)
+    hashstruct (1.3.1)
+    pathname3 (1.2.5)
+    rake (12.3.0)
+    rmagick (2.16.0)
+    spliner (1.0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  qttk!
+  rake
+
+BUNDLED WITH
+   1.16.1

data/README.markdown

@@ -0,0 +1,131 @@
+# Quadtone Toolkit (QTTK)
+
+## NOTE: This README is out of date relative to the current code. Apologies.
+
+QTTK provides a set of tools for printmakers who use the quadtone inkjet printing process.  It works in conjunction with the [QuadtoneRIP](http://www.quadtonerip.com) (QTR) grayscale printing system.
+
+At the moment, the software consists largely of libraries of code (written in the [Ruby](http://ruby-lang.org) programming language) and a single command-line tool.  Hence, it is probably not interesting to most printmakers unless they are either programmers or people comfortable with the Unix command line.  Additionally, printmakers who are happy with Epson's 'automatic black and white' mode, the default QTR profiles, or the [Piezography](http://piezography.com) system can probably feel comfortable in staying with the process they currently use.
+
+However, if you are interested in printing on obscure papers, hand-mixing your own inks, or otherwise want more control and knowledge over the printmaking process, these tools may help.  I originally wrote them because I was dissatisfied with the perception of the quadtone process being 'black magic,' inaccessible, or unscientific.  It is my hope that tools like QTTK will increase the understanding and acceptance of the quadtone inkjet process.
+
+At some point, given sufficient interest and motivation, I may write a graphical interface (GUI) to the underlying code.  In the meantime, please enjoy the art and craft of the [Unix command line](http://en.wikipedia.org/wiki/Command-line_interface).
+
+
+## Capabilities
+
+QTTK enables you to:
+
+  - Generate profiling targets to be printed and analyzed.  Many parameters can be set, including paper size, color mode (either QTR calibration or grayscale), ink channels, ink limits, and patch oversampling rates.  In addition to an image file (TIFF), a reference data file is also generated, which can be used by MeasureTool or other color profiling systems.
+
+  - Analyze measurements of printed reference targets.  Individual ink channels are detected, as well as tonal response curves, maximum-density points, and other data.  Grayscale ink separations can be easily calculated, as well as linearization curves for grayscale targets.
+
+  - Create visual charts and graphs of analyzed information, including response curves and density scales.
+
+  - Build and install QTR profiles, based on measured data, avoiding complex and error-prone manual calculations.
+
+  - Preview how images will print through particular QTR profiles, actually separating a grayscale image into the ink channels as represented in the the QTR curve files.
+
+QTTK intentionally makes few assumptions about equipment and materials. This allows for flexibility, as well as dealing with 'worst case' scenarios. Say you've obtained an old printer with a broken magenta channel, and a yellow channel that refuses to unclog. You've mixed your own inks by hand (using, say, Paul Roark's C6 base; see below for details) at some approximate dilutions. And you are using an exotic paper, not even designed for inkjet. QTTK's tools will allow you to make that a workable scenario.
+
+
+## Philosophy
+
+The development of these tools came out of a over a decade's work with the quadtone process, and a great deal of thinking about how these tools fit into the printmaking process.  From my experience, I came up with a short list of guiding principles (inspired by Christopher Alexander's *Pattern Language*) to serve as a basis for developing this software.
+
+  - Make tools, not products: Any craftsman has a set of tools which are optimized for specific uses, yet work together to solve a wide variety of problems. Having access to the right tools allows the printmaker to attain the same results as prepackaged, point-and-click software, or to indeed rise above those results. Therefore, design a decent set of tools that can be used in many ways. Further, design tools so they can be augmented or modified as needed.
+
+  - Encourage understanding of process: Much of the modern digital printing process is hidden beneath layers of abstraction and automation. This often denies the possibility of understanding how things really work. True craftsmanship relies on an understanding of materials, processes, and tools. Therefore, as much as possible, show the workings of the process, so they can be both understood and expanded.
+
+  - Apply scientific principles: Most digital printmakers use materials and equipment that are extraordinarily accurate (printers, computers, ink, paper), with results that are repeatable and measurable. Yet existing printmaking tools either discourage measurement at all (presuming that all situations are identical) or go about it using repetitive, error-prone manual methods. Therefore, encourage measurement and analysis (along with understanding of that analysis) at all points of the process.
+
+  - Allow craft & expressiveness: Art lies partly in vision, and partly in process. An artist must be able to work symbiotically with a process, experimenting with materials and observing reactions, and adjusting to those observations. A process that discourages experimentation or adjustments, or whose tedium results in an artist giving up on experimentation, will result in poorer art. Therefore, provide tools for experimentation, measurement, analysis, and production which encourage the highest level of craft.
+
+
+## Example usage
+
+There is a single binary command installed, called **qt**.  This binary has several subcommands, referred to here as 'tools'.  Here are a few examples:
+
+    # Add a new printer
+    qt add-printer Quad4000-C6
+
+    # Examine the printer's options
+    qt printer-options
+
+    # Make a directory for a new profile
+    mkdir GenericMatte
+    cd GenericMatte
+
+    # Initialize a new profile for a given printer, specific inks, and a particular resolution
+    qt init --printer Quad4000-C6 --inks K,C,M,LC,LM,Y --resolution XXX
+
+    # Create characterization and linearization target files (both data & images)
+    qt target
+
+    # Print the characterization target
+    qt print --calibrate characterization.reference.tif
+
+    # Measure the printed characterization target
+    # (measure using MeasureTool, save as 'characterization.measured.txt')
+
+    # Characterize the profile based on the measured data; also install as QTR curve
+    qt profile
+
+    # Print the linearization target
+    qt print linearization.reference.tif
+
+    # Measure the printed linearization target
+    # (measure using MeasureTool, save as 'linearization.measured.txt')
+
+    # Generate SVG chart for measured linearization target (open with SVG-aware browser)
+    qt chart linearization.measured.txt
+
+    # Generate SVG charts for profile (both characterization & linearization) (open with SVG-aware browser)
+    qt chart
+
+    # Read image.jpg and create grayscale channel separations, based on existing curve (outputs montaged separations to image.tif)
+    qt separate /Library/Printers/QTR/quadtone/Quad4000-C6/GenericMatte.quad --montage image.jpg
+
+
+## Printing a target
+
+It is essential that you can print a target without its values being modified by the application that's printing it. I have had little luck with Lightroom, and Photoshop has been classically tricky to get right, especially on a Mac. OS X's Preview application seems to do fine, as does Adobe Color Printer Utility.
+
+
+## Measuring a printed target
+
+First, let the profile dry completely at room temperature, or use a hair dryer, microwave oven, or other heater to dry more quickly.
+
+Place several (2-3) sheets of paper of the same type as the printed target on your workspace, with the printed target on top. (This ensures that the workspace color will not affect the readings.)
+
+When using a strip-reading spectrophotometer, move the instrument slowly across the strip being read. If a row continues to have errors, you may need to read the patches spot by spot, instead of by strip.
+
+
+## Installation
+
+Prerequisites:
+
+- Mac OS X (10.6 or later)
+- Ruby (1.9.2 or later)
+- Various Ruby modules (see `qttk.gemspec` for latest requirements, but generally these will be installed automatically)
+- [ImageMagick](http://www.imagemagick.org) (6.7 or later)
+- [ArgyllCMS](argyllcms.com) (1.3.6 or later)
+- [QuadtoneRIP](http://www.quadtonerip.com), Roy Harrington's [QuadtoneRIP](http://www.quadtonerip.com) shareware ($50) grayscale RIP system.  For Windows, it is a standalone application; for OS X, it is installed as a set of printer drivers and supporting profiles and other resources.
+- an inkjet printer supported by QTR (see [QTR requirements](http://www.quadtonerip.com/html/QTRrequire.html)), loaded with several gray shades of ink
+- an EyeOne (i1) spectrophotometer (other devices, perhaps including flatbed scanners, to be supported in the future)
+
+I highly suggest that you install Ruby using [RVM](https://rvm.beginrescueend.com/), ImageMagick using [Brew](https://github.com/mxcl/homebrew), and ArgyllCMS and QuadtoneRIP using their respective binary package installers.
+
+Once the above packages are present, install QTTR by typing:
+
+    $ gem install quadtone
+
+QTTK has been developed and tested under Mac OS X Lion (10.7).  While it is in the development phase, QTTK is not designed or guaranteed to be usable on any other versions of OS X, or indeed any other systems.
+
+
+## Further information and resources
+
+- Paul Roark has an extremely useful library of [Digital Black & White Printing Information](http://www.paulroark.com/BW-Info/).  His work on 'homebrewed' carbon inkjet inks (see <http://www.paulroark.com/BW-Info/Ink-Mixing.pdf>) is particularly valuable to me, and will be for any aspiring printmaker.
+
+- Jon Cone and his associates have been pioneers in quadtone inkjet printing.  Their [Piezography](http://piezography.com) system has gone through several incarnations, and was where I started quadtone printing with the now-antique Epson 1160.  Although they now utilize QTR as their software, they use a proprietary method of generating much smoother curves.  They also sell their own quadtone inks, in a variety of tones and channels.
+
+- [MIS](http://www.inksupply.com/bwpage.cfm) (aka InkSupply.com) is one of the primarily distributors of quadtone-capable inks.  They sell a variety of inks in both pre-packaged cartridges for many Epson printers, as well as bulk bottles so you can refill or mix your own.  The black pure-carbon pigment product [Eboni-6 (K)](http://www.inksupply.com/product-details.cfm?pn=UT-HEXPT-K) is the usual starting point for most homebrewing printmakers.  With that, plus the ingredients for Paul Roark's C6 base, you'll be making your own inks and, hopefully, profiling them with QTTK.

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/gem_tasks'
+rescue LoadError
+  warn 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  exit(1)
+end
+
+require 'rake/clean'
+require 'rake/testtask'
+
+spec = Gem::Specification.load(FileList['*.gemspec'].first)
+
+task :default => [:test, :install]
+
+Rake::TestTask.new do |t|
+  t.test_files = spec.test_files
+end

data/TODO.markdown

@@ -0,0 +1,236 @@
+# TODO
+
+  - move target data/logic from CurveSet to Target
+
+  - add <xml> tag to SVG-only output
+
+  - build linearization as strip chart
+    - compare quality against spot chart
+
+  - for each new characterization/linearization, add 'session'
+    - each in dated directory
+    - for 'process', each characterization/linearization is averaged
+    - can delete specific -zation
+
+  - improve Color class
+    - allow instantiation by different methods:
+      - color: color object that responds to #to_<color> (eg: Color::CMYK.new(Color::RGB.new(0,0,0)))
+    - use natural scale for each subclass:
+      - RGB: scalar (255 / 65535)
+    - implement basic math
+      - add, subtract, divide, multiply
+    - add tests
+      - creation/serialization/deserialization
+      - equality/comparison
+      - math
+    - move to separate gem
+
+  - simplify spline curves?
+    http://stackoverflow.com/questions/5525665/smoothing-a-hand-drawn-curve
+    http://www.codeproject.com/Articles/18936/A-Csharp-Implementation-of-Douglas-Peucker-Line-Ap
+
+  - add 'check' tool to check attributes & values of profile
+
+  - better command-line option parsing:
+    - tool should just declare attributes, setters
+    - options can come at beginning or end
+
+  - implement actual subclasses of CurveSet for colors, instead of using @color_class
+
+  - split main 'qt' tool into separate binaries:
+    - qtprofile: manage profiles
+    - qtprinter: manage printers
+    - qtpaper: manage paper types
+    - qtprint: print images
+
+  - test linearization
+    - print grayscale target image with QTR curve, then measure target
+    - analyze measured target
+      - build grayscale curve from samples
+      - test for linear response
+      - show dMin/dMax, Lab curve
+    - store each test with timestamp
+    - chart scale over time (with multiple tests)
+      - graph differences between values
+      - graph average dE
+        - see: http://cias.rit.edu/~gravure/tt/pdf/pc/TT5_Fred01.pdf (p. 34)
+
+
+  Target specs:
+
+    width of page               11"
+    width of strip              <= 9.5" (24.13cm)
+    patch size (scan direction) >= 10mm (28pt)
+    patch size (perpendicular)  8mm (23pt)
+    gap size in scan direction  0.5mm - 1.0mm (2pt)
+    optimum patches per strip   21
+
+
+***
+
+  new process (* = user action)
+
+    1. initialize
+
+      - get profile name from current directory
+      - get printer name from argument, or use default
+      - get PPD/etc. for printer
+      - get inks for printer
+      - modify inks from arguments
+
+      % qt init [--printer=Quad-C6] [--inks=-M]
+
+    2. characterize
+
+      a. print characterization target
+
+        - generate characterization target for selected printer's ink channels
+          - one curve per channel, value on 0..1 scale
+          - one column per channel
+          - for each row:
+            - solid patch of given value (for spot reading)
+            - patch with small rectangle of given value inside larger rectangle of maximum value (like current ink limits chart)
+            - solid patch of given value, with thin white lines
+
+        - print characterization target
+          - in calibration mode
+
+        % qt characterize
+        % qt print ...
+
+      b. user examines printed target
+
+        - looks for overall ink quality
+        - finds patches with maximum density
+        - ignores unneeded channels
+
+      c. measure characterization target
+
+        - map patch IDs from arguments to patches
+        - measure spots (using 'spotread')
+        - map patches to per-channel ink-limit value
+        - channels with no patches specified are disabled
+        - save ink limits as L*a*b
+        - calculate ink order
+        - create curveset for enabled channels
+          - apply ink-limits
+
+        % qt characterize <patch-1> <patch-2> ...
+
+    3. profile
+
+      - generate QTR profile
+      - install QTR profile
+
+    4. linearize (either per channel or composite grayscale)
+
+      a. print linearization target
+
+        - generate linearization target
+          - create curveset for color model
+          - if per-channel:
+            - apply ink limits
+          - generate .tiX files for chartread
+          - generate target image
+
+        % qt linearize { --raw | --composite> }
+        % qt print [--calibrate] <target-file>
+
+      b. measure linearization target
+
+    5. test
+
+      a. print test target
+
+      b. measure test target
+
+        - save test results
+
+    6. visualize
+
+      - ink order, color
+      - ink limits
+      - overall linearization (color, error)
+      - density range
+      - QTR curves
+      - channel separations for a given image
+
+***
+
+- Improve profile initialization:
+  - Use CupsFFI instead of 'lpadmin' to determine default printer.
+  - Add initial ink-limit to profile/target.
+    - To allow for more accurate results on papers known to be very absorbent.
+    - From posting on DigitalBW: "Find the limit of the full black ink by watching for
+      slight puddling and or printing a pattern with some 1 pixel spaced white lines
+      surrounded by much larger areas of solid black. When the edges of those 1 pixel
+      lines start to get fuzzy, you have too much ink.
+  - Allow negation of inks (eg, '-LLK').
+  - Find good printer defaults:
+    - Medium/high resolution (1440/2880).
+    - Unidirectional ("lospeed").
+    - Dithering mode ("Ordered")
+  - Save curves to profile so they are only generated once (when profiled).
+
+- Improve target generation:
+  - Add info banner to target:
+    - Mode (characterization, linearization, etc.)
+    - Date
+    - Profile info (printer, paper, inks)
+
+- Improve analysis:
+  - Experiment with whether more steps or over-sampling is better.
+  - Determine optimum delta-E for ink detection (& make configurable).
+  - Detect & remove bad ink:
+    - Too much deviation in samples.
+  - Calculate dot gain.
+    - http://www.brucelindbloom.com/index.html?Eqn_DotGain.html
+  - Verify limiting/separation algorithms.
+    - Generate sample data.
+    - Write tests to verify operations.
+    - Scale gray values in profile by ink limits?
+        http://lists.apple.com/archives/colorsync-users/2007/Jan/msg00379.html
+        http://www.colorforums.com/viewtopic.php?t=80
+        http://www.onyxtalk.com/thread-understanding-ink-limits
+  - Generate our own QTR curves.
+    - Pre-linearize of individual channels.
+    - Create smoother curves (using bsplines?).
+  - Use L* profiling?
+    - http://tech.groups.yahoo.com/group/QuadtoneRIP/message/9691
+
+- Improve charting:
+  - Optionally normalize curves in charts.
+  - Represent a/b for measured (L*a*b) colors.
+  - Parameterize error threshold.
+  - Show individual sample points.
+  - Display densities using log scale?
+  - Use Jones diagrams for showing data <http://en.wikipedia.org/wiki/Jones_diagram>.
+
+- Add confirmation/testing step to profiling:
+  - To test ink settling, sample fading, etc.
+  - Show actual tonal response curve.
+  - Show Lab curve (eg, ink color).
+  - Show charts for final curves.
+  - If multiple test results exist:
+    - Graph change of linearization, density range, color, etc.
+
+- Build web interface.
+  - Create account.
+  - Create new profile.
+  - Generate reference/target files.
+    - Download as ZIP archive.
+  - Upload measured files.
+  - Analyze/visualize measurements.
+  - Generate QTR profile.
+    - Download QTR profile.
+  - Maybe small raw-printing utility, in MacRuby?
+  - Eventually, curve-builder and installer?
+
+- Test/rewrite 'add-printer':
+  - Use CupsFFI instead of shelling out to 'lpadmin', etc.?
+
+- Create guide for process (on wiki).
+
+- Use Gutenprint to generate DeviceN or ESC/P2 files?
+
+- Document classes & methods.

data/bin/qt

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.realpath(File.dirname($0)), '..', 'lib'))
+
+require 'quadtone'
+
+Quadtone::Tool.process_args(ARGV)