History of Changes in Treemap

Online Documentation for Treemap 4.1

New Since Treemap 4.1.1

Treemap 4.1.1 was released on February 17, 2004.

  • The combo box for size attribute initializes correctly when settings are applied from a tms file.
  • When a NetViz Table is imported, NetViz links are shown globally by default.
  • The message that appears for negatively valued size attribute shows which attribute it is.
  • Minor bug with the label headings is fixed.

New Since Treemap 4.1.0

Treemap 4.1.0 was released on February 2, 2004.

    For details see also the online documentation.

  • Feature Set functionality is added.
    Now, you can customize the features in Treemap! You can remove Menus, MenuItems, tabs in Control Panel and the Attribute Table. You can dynamically exclude or include whichever features you want either when Treemap is running or specify it as a command line argument in the batch file (run.bat) so that you don't have to apply your feature set every time you start Treemap.

    To the licensee:
    FeatureSet functionality is implemented with ease of extendability in mind. The features are implemented using enum logic in Java. (There is no enum in Java, but it is effectively simulated.) The components representing features are either registered or recycled (anything that cannot be made invisible by using setVisible(false) is recycled). If you add new features to Treemap such as new CheckBoxes, new tabs in Control Panel, or new MenuItems, you can exploit the extendability of FeatureSet functionality. Only a few additions to the right places in the code should be sufficient.

  • NetViz (Network Visualization) links feature is added.
    Now, you can provide additional data to Treemap that will enable you to visualize Bezier curve links among nodes. The additional data is in the form of a .tnv file, the format of which is explained in the documentation. The link colors can be customized according to a nominal attribute of the destination node. When mapping a directory, you will be asked whether you want NetViz links to be generated automatically. If this directory is a website containing HTML references, namely HREF and SRC, you will be able to see all local links. This is very useful for example, if you want to reorganize your website but update the links correctly when you move a file that has links to and is linked from other files.
    This new feature has also been presented as a short paper in the Interactive Poster section of the InfoVis2003 conference: Overlaying Graph Links on Treemaps

  • Command line arguments are redesigned as switches.
    Command line arguments enable to specify an input data file which will open as soon as Treemap starts, or a directory which will be mapped when you start Treemap. You can also highlight a node by providing its label, and have Treemap apply a FeatureSet when it starts up.

  • Now, you can provide your input data in XML format to Treemap.
    This was a feature so frequently requested that we couldn't help implementing it. It is also well integrated with other features in Treemap such as saving settings (.tms files, i.e. you can save the settings of an XML input data file the same way you would save the settings of a TM3 file), and exporting (you can export selected parts of the data as XML files that can be input to Treemap later).

    To the user concerned about performance:
    Try to use TM3 format whenever possible. TM3 files are faster to read into Treemap and it is much faster to export parts of the data as a TM3 file.
    In the performance tests we conducted, it took 9 seconds to read in a 20MB XML file on a 1GB RAM, 2.4GHz Dell machine. Reading XML files has been implemented using SAX parser for efficiency. Exporting an XML file is much less efficient, though, this is because it is implemented using DOM XML functionality. In the tests, Treemap performed twice as much slower when exporting data as an XML file as opposed to exporting it as a TM3 file. It also needed twice as much or more memory.

    To the licensee:
    You can find the XML reading/writing functionality in the "io" package.

  • Export functionality is re-implemented.
    The previous export functionality would only work for TM3 files and would depend on the TM3 input file that the data was loaded from at the time of export. Now, the export functionality depends only on the data that is already loaded in Treemap (as it should be this way, really). As a result, export functionality works no matter what the format of the input file was. Exporting an XML file is also supported now.

    To the licensee:
    The export functionality is separated from TreemapModel and put into io package for cleanliness. The "writer"s in io package are responsible for performing the processing for export functionality.

  • Applying settings has been optimized.
    If there are many attributes having different colors, applying the settings would take a tremendous amount of time for large data. This was also causing problems in Step 3 of directory mapping. Step 3 was the major bottleneck when mapping a large directory previously requiring a lot of time and resources. After the optimization, step 3 became ironically the step that takes the least amount of time in mapping a directory. For small enough data, step 3 may complete so fast that you may not have a chance to see the dialog box for it (!).

  • Mapping directory functionality re-implemented for significant optimization.
    The dialog boxes containing ProgressBar's in step 1 and step 2 of directory mapping are brand new. Although they have the same look as before, they are much faster because they are multi-threaded and the progress message is printed less frequently but often enough for a human not to notice any delays. They are also robust. You can move the dialog boxes around and still see the treemap in the background. Also, you can cancel the directory mapping task and return to the previous state of treemap. (Previously, you would lose the previous state of treemap once you chose to map a directory, and sometimes cancelling wouldn't work.)

    To the licensee:
    The JDialogBox'es of step 1 and 2, which monitor progress, use the new package in Treemap. This new package is called task and allows multithreaded updateable thread-safe JDialogBox'es similar to the ones you see see for Step 1 and Step 2. This package together with its sub-packages is reusable. Hence, if you need a similar JDialogBox to show progress, you can use it. The most important property of Task is that it allows to sample the progress information in fixed intervals, or in triggered form (the trigger condition determined by the programmer). For example, Step 2 of Directory Mapping, it will consume much more time if every file that is examined it printed in the dialog box. Instead, the directory path is printed every 5ms or so, which happens to save a lot of time!
    For tasks that sampling is not needed, a simpler component is provided: SimpleProgress. For example, the last step of directory mapping uses SimpleProgress, whereas step 1 and 2 use TaskProgress.

  • Mapped directories now behave the same as data loaded from input data files (TM3, XML).
    Previously, you could map a directory but it wasn't possible to export part of it (in TM3 format). Now, you can export it (as TM3 or XML)! Previously, you could map a directory and save a .tms file. But when you opened that .tms file, it would re-map the same directory. Moreover, if you removed the directory in the meantime, or the directory structure has been changed, you needed to be lucky not to run into problems (For example, Treemap could crash if you weren't lucky). Now, it is different. Now, saving settings after mapping a directory is much like saving settings of a regular data. The only difference is that there is no data file! Hence, it will be created for you. For example, if you map a directory and Save Settings into a file named "mydir.tms", automaticallu Treemap will create "mydir.tm3" for you in the same directory which contains the data for the directory structure. When you open "mydir.tms" file, it will load the data in "mydir.tm3" and then apply the settings to it.

  • Input/Output functionality has been further separated and organized.
    Opening files and exporting files are made more robust. It all depends now on the extension of the file name you provide or select from the JFileChooser. For example, if you export and give the file name as "mydata.tm3", it will be exported in TM3 format. If you give the file name as "mydata.xml", it will be exported in XML format. Similar dynamic processing exists for opening a file, too. (Also true for .tms files referring to .tm3 or .xml files.)

    To the licensee:
    The "filereader" package in Treemap 4.0.5 is renamed as "io" in Treemap 4.1.0. There are two reasons for the new name of the package:
    1. "io" is much more appropriate than the name "filereader" as output functionality (export) is symmetric to the input functionality (open file), and had better be in the same package, and is now in the same package so it is not a package containing only "reader"s any more. (It also contains "writer"s.)
    2. they are not File's any more, but URL's, so the "file" in the name is not appropriate any longer. The reason for them to be URLs now is so that Treemap can work as an Applet, too (a restricted version, though, due to security restrictions of Java Applets).

    The inheritence relationships of classes in the "io" package has been improved. TreemapFileReader is an abstract factory (a design pattern) now. There is a new superclass called ValueDecoder. Commonly used methods are pulled up to superclasses as much as possible. TreemapModel uses the superclasses that are already in the "io" package. Since the reading/writing functionality depends on the extension of the file name, have Treemap be able to read a new format should be much easier. Most of the time, it should suffice enough to extend the appropriate superclass, (for example, TreemapFileReader for reading in), implement its methods and do only a few additions to the right places in the code (add another if statement in TreemapFileReader.newInstance(), use filefilter.GenericFileFilter, etc.) and everything should work fine. For more sophisticated loading of data such as access from databases, you may be able to use the higher superclasses (such as extend ValueDecoder rather than TreemapFileReader).

  • The labels in Treemap can span multiple lines, now.
    Previously, only the first line would be used in a label. If the label didn't fit the first line, it would be truncated. Now, it wraps around and continues on the next line. If not absolutely necessary, a word doesn't span multiple lines. A word only spans multiple lines if the width is so narrow that it doesn't accommodate even one word.

  • The PopUp size is corrected.
    The PopUp size would sometimes be wider than necessary. Now, it is as large as it needs to be.

  • Recovery when memory is exhausted rather than exit Treemap.
    Previously, Treemap would crash and exit when there wasn't enough memory for a task. Now, a mechanism is added to nicely recover from situations where memory is exhausted.

    To the licensee: Look at the use of debug.HandleMemory class. It has the recovery functionality encapsulated. It has a simple use (1 statement). If you are satisfied with the generic message when recovering from an OutOfMemoryError, you can reuse it in the same way if you add new code.

  • The source code has been reorganized into 8 packages (+2 subpackages).

New Since Treemap 4.0.5

Treemap 4.0.5 was released on August 7, 2003.

  • Treemap Applet version is made available. The code has been refactored to enable Treemap work as an applet as well as an application.
  • Startup time enhanced. Treemap starts up faster than before. The time internal data structures are initialized is overlapped with the time that the initial image appears.
  • The initial image disappears when it is clicked on.
  • .tm3 and .tms files can be in any directory now. Previously, they had to be in data/ directory. Now they can be in any place as long as the corresponding .tm3 file is in the same directory as its .tms file.
  • Reading .tm3 file functionality has been revised. It is replaced with new code that is cleaner, more maintainable, understandable and faster.
  • The source code is reorganized into three packages.

New Since Treemap 4.0

Treemap 4.0 was released on April 14, 2003.

  • The DATE attributes are now handled as dates and not as strings. They can be binned and ordered (similar to numerical attributes) while creating hierarchies, and in the legend options.
    NOTE:Make sure the format for entering date values is MM/dd/yyyy. For more information, go to Create your own data file.
  • Better way to handle java outofmemory error when we map a large directory or file. A new Instead of using concurrent programming technique to monitor memory usage at runtime (which has a negative effect on Treemap performance), whenever Java's Out of Memory Error occurs, appropriate messages are written to an external file (see LOGFILE.TXT) that describes briefly the type of error and the approximate location where TreemapProgram failed to proceed.
  • A new progress bar showing three steps while mapping directories is included.
  • A "weighted average" option is added in the aggregation. Weighted average uses the size attribute to weigh the average calculation.
  • The filtering while lower levels of the tree are aggregated has been fixed.
  • Treemap 4.0 now supports the keyboard navigation. The following keyboard shortcuts are added.
    • The mnemonics for all the menu options are added. The mnemonic for option is underlined. For example, for file menu, alt+f will make the file menu selected, then 'o' for file open, 'd' directory mapping etc.
    • The keyboard shortcuts are displayed on the menus.
    • Some of the shortcuts that are not displayed are:
      • "Esc" - zooming in the tree
      • "Enter" - Zooming out the tree for the selected node
      • "F1" - help, will give the quick reference for the treemap documentation.
      • "Up Arrow" - highlights the parent node for the selected node.

New Since Treemap 4.0 Beta Version

Treemap 4.0 Beta Version was released on February 11, 2003.

Flexible Hierarchy
  • You can create new hierarchies based on attribute values. For example you could group projects by project type, then by PI name; or you could do the reverse: first group by PI, then by project type.
  • Numerical attributes can be "binned". For example the project budget values could be binned into 2 bins: the small budgets and the big budgets. An histogram shows the distribution of numerical values and you specify where the bin separators should go.
Color Binning for Numerical Attributes
  • A color setting widget will appear for numerical attributes, that serves as a color legend, a histogram showing the distribution of values, and a data entry widget to set ranges (i.e. bins) of values, and assign them different colors.
  • There are three binning options provided: Equally Spaced Bins, Equally Dense Bins, and User Defined Bins.
  • You can click on the "MIN" or "MAX" button to select colors. When the bins are small and hard to highlight with the cursor, you can cycle through the bins by clicking on the "Previous" and "Next" buttons.
Color Settings
  • You can choose a logarithmic, square root or a linear scale.
  • You can specify specific ranges - or "bins" and assign colors to them
    By filtering in the maximum depth, you can aggregate lower levels of the tree.
Directory Mapping
  • Directory Mapping has been improved with better color mapping for file type and file age.
  • There is a default name proposed by the dialog box for the settings to be used with any directory you want to map, "directory_settings.tms".
Automatic Reload
    This allows you to use Treemap to monitor data changing overtime.
    Export enables users to export nodes sharing common attribute properties.
  • You can remove the borders to give more pixels to the nodes, making more of them visible.
  • Settings can be saved in a settings file that - when opened - automatically load the data file and set the settings as they were saved.
  • Many filtering bug fixes: e.g. auto repeat fixed, filtering for nominal valued added.
  • You can chose the filtering widget to be made of radio buttons, check boxes, item slider or range sliders, by right clicking on the attribute name.
  • During parsing of the data file, the empty cells are recognized and users warned.
  • There will an automatic update of the data in the *.tms file. The *.tms file will be reloaded every x seconds with a warning message that will allow users to cancel reloading process.
  • There is a new option provided in the "Option" menu of the main menu bar. This option is "Set Path Highlighting Color" which enables you to change the color of all the parents of the selected node.

New Since Treemap 3.2

Treemap 3.2 was released on February 25, 2002.
  • Strip treemaps algorithm implemented
  • Control panel layout changed to fix formatting bug
  • Full Documentation (HTML format)
  • Packaged as a jar file
  • Logrithmic coloring algorithm improved
  • Pop-up enable option added to option menu
  • Various code improvements

New Since Treemap 3.1

Treemap 3.1 was released on November 15, 2001.
  • Ability to save and load settings
  • Nominal colors are kept for each attribute
  • Additional nominal colors added
  • Display showing number of nodes visible and percentage
  • Increased size of range slider buttons
  • Ability to select and hide nodes
  • Ability to set the Treemap title
  • Logarithmic as well as linear coloring scales
  • Treemap depth indicator
  • Label shutoff for faster dynamic queries with auto hide enabled

New Since Treemap 3.0

Treemap 3.0 was released on June 2001.
Treemap 3.0 Online Demo (java applet of an older version.)

Offered the squarified layout as well as slice-and-dice, with dynamic query sliders to support exploration. It provides mouse-over details-on-demand, supports better control on coloring, facilitates input of new data sets, enables printing, and allows saving of state. We also provide improved help and dramatically faster loading for large files (over 1000 nodes). Treemap 3.0, written in Java, is a substantial improvement on Treemap2000.

Treemap 3.0 began with the work of Raghu Chalasani (Treemap2000) during Summer 2000 under the direction of Ben Shneiderman. The expansion to Treemap 3.0 was carried out by Ketan Babaria, Steve Betten, and Jim Blowitski, in consultation with Catherine Plaisant and Ben Bederson, during Spring 2001.

Webpages of earlier versions :
     Treemap2000 application , and an old tutorial explaining its features.

See also:  history of Treemaps maintained by Ben Shneiderman.