• Like
Vips 4mar09f
Upcoming SlideShare
Loading in...5
×
Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
105
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
0
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. VIPS: An Image Processing Library for Large, and Not So Large, Images
      • John Cupitt
      • Imperial College
      • London, UK
      • Kirk Martinez
      • University of Southampton
      • Southampton, UK
    Presented by Nicolas Robidoux LGM Montreal, 2009 http://www.vips.ecs.soton.ac.uk
  • 2. Introduction
    • VIPS is a 2D scientific image processing system. It needs little memory and runs quickly, especially on multi-CPU machines. It has good support for large images and for colour.
    • The library is mostly C with some C++. There are C, C++, Python, GUI and command-line interfaces. It runs on any Unix, with convenient packages in the major distributions, and on Windows. It is licensed under the LGPL.
    • The GUI is an unsual blend of a spreadsheet and a paint program. It is licensed under the GPL.
  • 3. Speed and memory use
    • Load, crop, shrink, sharpen and save a 5k x 5k pixel RGB tiled TIFF image. Fastest real time of three runs on a quiet system. Tests run on a 2 CPU Opteron server.
    • Image and Graphicsmagick both compiled with Q16. Freeimage does not have a sharpening operation, so that part of that test was skipped. nip2 seems slow because it has a long start-up time: once it starts, it processes at the same speed as the Python and C++ versions. Octave (Matlab) does not aim to be quick, we include the time for interest. The source-code for the various implementations is on the VIPS website.
  • 4. SMP scaling
    • Load, crop, shrink, colour-correct, sharpen and save a 10k x 10k pixel CIELAB image in VIPS format. Number of CPUs on horizontal axis, speed-up on vertical. Run on a 64-CPU Itanium2 supercomputer (SGI Origin 2000). Details of the benchmark and source-code are on the VIPS website.
  • 5. History
    • VIPS was started in 1990 as the image processing system for the VASARI project (multispectral imaging of old-master paintings to detect long-term colour change).
    • 10,000 x 10,000 pixels, seven colour bands, 16 bits per band, up to 1.6 GB for the final image.
      • Our Sun4 had 64 MB of RAM and a 25 Mhz processor. Ouch!
  • 6. History
    • VIPS therefore looks something like this:
    • Several operations run at once and images are pulled through the pipeline by demand from the sink.
    • A simple, lightweight system combines operations without the need for large intermediate images.
  • 7. History
    • We added SMP support in 1993:
    • Run a pipeline on each thread, sinks arrange synchronisation.
  • 8. History
    • We added large file (>2GB) support in 2002:
    • We map a small window into each input file. These windows are shared between threads when possible. Window positions are calculated using 64-bit arithmetic.
  • 9. History
    • We improved SMP scaling in 2006:
    • A buffer manager decouples workers from the image write library so they never have to wait. We also added a system for quickly sharing and recycling pixel buffers.
  • 10. General principles
    • 2D colour images only: no video, no volumes
    • Any number of bands
    • All band elements in an image have the same pixel format (eg. 32-bit signed int)
    • All operations are non-destructive
    • Images are uninterpreted arrays. Alpha channels, CMYK, layers, etc. are up to applications to implement on top of VIPS
    • Pipelines are static. Apps have to destroy and rebuild to make a change.
  • 11. API
    • The C++ and Python APIs are similar to PIL. The C API is somewhat like HIPS, if anyone remembers that.
      • import sys
      • from vipsCC import *
      • im = VImage.VImage (sys.argv[1])
      • im = im.extract_area (100, 100, im.Xsize () - 200, im.Ysize () - 200)
      • im = im.similarity (0.9, 0, 0, 0)
      • mask = VMask.VIMask (3, 3, 8, 0,
      • [-1, -1, -1,
      • -1, 16, -1,
      • -1, -1, -1])
      • im = im.conv (mask)
      • im.write (sys.argv[2])
    • Load, crop, shrink, sharpen, save. The Python binding is generated automatically by SWIG.
  • 12. Other features
    • Pixels can be 8/16/32-bit integer, signed and unsigned, 32/64-bit float, 64/128-bit complex
    • XYZ, Lab, Yuv, Yxy, Lch, RGB colour spaces; ICC colour management with lcms
    • Operation database, plugins, metadata, many file formats, memory, disc and screen sinks
    • ~350 operations, mostly simple filters: rank, Fourier, morphological operators, convolutions, histogram operations, colour, arithmetic, affine
    • Simple: ~10k lines of C for the core, 50k in operations
  • 13. GUI
    • nip2, the VIPS GUI, is a spreadsheet where each cell can be a complex object: an image, plot, widget, matrix, etc.
    • nip2 has its own lazy, higher-order, pure functional language with classes, somewhat like dynamically typed Haskell. Spreadsheet cells are class instances. Cells are joined with snippets of this language.
    • As the spreadsheet recalculates it builds optimised VIPS pipelines behind the scenes. Image generation is then pure VIPS.
    • So: fast, low memory use, huge images.
  • 14. GUI
  • 15. GUI
    • You can use nip2 for quite large, complex applications. We have a set of linked workspaces which analyze four-dimensional images (volumes over time) from PET scanners to calculate tissue inflammation indicies.
    • The workspaces read ~300MB of image data, process ~7,000 images, generate ~60 GB of intermediate images and take ~2 minutes to completely recalculate. They need ~400 MB of RSS to run.
    • A useful tool for a technical user, not aimed at a general audience.
  • 16. GUI
  • 17. Bad things about VIPS
    • Rather old-fashioned, slightly clunky C API
    • Still uses manpages. We get a lot of complaints about hard-to-navigate docs.
    • Limited range of operators. It would be nice to have segmentation, for example.
    • Awkward to extend, despite a plugin system. Operators have a fixed set of arguments and it's difficult to add functionality.
  • 18. TODO
    • We've started moving VIPS to GObject.
    • The current stable version has several GObject-based systems. We plan to move most of the VIPS types to GObject in the next version, then start rewriting operations in the version after. We will switch to doxygen for API docs.
    • This should give us a sane, extensible, well-documented, easy to bind API with hopefully similar performance to the current version.
    • We'll aim to have a vips7 compatibility layer
  • 19. Other stuff we could talk about
    • Contrast Gegl vs vips
    • Users ... museums, medical, university, ...?