Started 8/26/2001 by Bob Futrelle

This page lays out some overall systems issues. For all of the work outlined here, I can furnish all the books and software resources we'll need. The system software and data files will be kept in secure subdirectories of /proj/futrelle/.

We will be doing a lot of pixel-level computations. We must be able to "see what we're doing" in order to discover what works and what doesn't and how it succeeds or fails. Some of the ways to make this happen are as follows:

• We must have a basic interactive capability, with windows, menus and cursor controls. This means will be building a Swing app.
• We must be able to see the original JPEG images, presented as various resolutions and scalings, gray-scale vs. color, etc. This will primarily require Java 2D, not full-scale JAI.
• We must build "fat-pixel" representations of the images that allow us to overlay representations of the various "pixbots" that we build. Their progress must be shown dynamically and the various parameters and data traces that they're producing must be shown dynamically in separate windows. (The lack of such views of the progress of pixel-level computations is one of the weaknesses of all other approaches to date. Part of this problems has been the difficulty of building such interfaces. This will not be easy for us, but Swing will make it easier and its so important that we must do the work required.)
• We will focus initially on discovering straight lines. Though this may sound trivial, it is not, primarily because lines in diagrams "collide" with many other items. Also, they're not always clean and also, weak curves look locally like straight lines. In addition, developing the dynamic pixbot viewers for straight lines will be an important step towards building them for all our bots.

Client-Server modularity: Initially, all this work will be done as Java applications on Solaris. They can be run from any workstation, via X windows of course. Further down the line, we'll look into setting them all up as remote applications, via RMI. It will be important to have these future plans in mind as we work, so we won't have to completely re-engineer our system later. This means that from the start, we must divide the system into two major subsystems, the interactive system and the compute engine. These later will become the client and server.

How to proceed: I'm developing my own personal notes on the algorithms and data structures for the project. I'll explain them as we go. Some of the first things we need to do are the following:

• Build a tiny Swing app that displays an image when the file name is typed in. Since Swing can deal with JPEGs directly, we can start that way.
• Then move the system to one that converts the JPEG to a raster image and displays that. This will require 2D and maybe not JAI.
• Then display part of the image as fat pixels using fat pixel utilities we build. Also, add some graphics overlay to them -- should be easy, since the fat pixels are graphics themselves.