Saturday, 31 May 2014

How to Avoid ConcurrentModificationException when using an Iterator

Java Collection classes are fail-fast which means that if the Collection will be changed while some thread is traversing over it using iterator, the will throw a ConcurrentModificationException.
This situation can come in case of multithreaded as well as single threaded environment.
Lets explore this scenario with the following example :

From the output stack trace, its clear that the exception is coming when we call iterator next() function. If you are wondering how Iterator checks for the modification, its implementation is present in AbstractList class where an int variable modCount is defined that provides the number of times list size has been changed. This value is used in every next() call to check for any modifications in a function checkForComodification().

Now comment the list part and run the program again.

Output will be:

Map Value:3
Map Value:2
Map Value:4
Since we are updating the existing key value in the myMap, its size has not been changed and we are not getting ConcurrentModificationException. Note that the output may differ in your system because HashMap keyset is not ordered like list. If you will uncomment the statement where I am adding a new key-value in the HashMap, it will cause ConcurrentModificationException.

To Avoid ConcurrentModificationException in multi-threaded environment:

1. You can convert the list to an array and then iterate on the array. This approach works well for small or medium size list but if the list is large then it will affect the performance a lot.
2. You can lock the list while iterating by putting it in a synchronized block. This approach is not recommended because it will cease the benefits of multithreading.
3. If you are using JDK1.5 or higher then you can use ConcurrentHashMap and CopyOnWriteArrayList classes. It is the recommended approach.

To Avoid ConcurrentModificationException in single-threaded environment:

You can use the iterator remove() function to remove the object from underlying collection object. But in this case you can remove the same object and not any other object from the list.

 Let us run an example using Concurrent Collection classes:


Tuesday, 27 May 2014

How to Column Selection in IDE Eclipse

Eclipse used to need a column mode plugin to be able to select a rectangular selection.

column mode 

Since Eclipse 3.5, you just need to type Alt+Shift+A: see its News and Noteworthy section. (On OS X it's Option-Command-A.)

block (aka column or rectangular) selection mode 

Or activate the 'Editor Presentation' action set ( Window > Customize Perspective menu) to get a tool bar button for toggling the block selection mode.

Thursday, 22 May 2014

Merging two images

Just create a new BufferedImage with transparency, then paint the other two images (with full or semi-transparency) on it. This is how it will look like:
combining images
Sample code (images are called 'image.png' and 'overlay.png'):
File path = ... // base path of the images

// load source images
BufferedImage image = File(path, "image.png"));
BufferedImage overlay = File(path, "overlay.png"));

// create the new image, canvas size is the max. of both image sizes
int w = Math.max(image.getWidth(), overlay.getWidth());
int h = Math.max(image.getHeight(), overlay.getHeight());
BufferedImage combined = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

// paint both images, preserving the alpha channels
Graphics g = combined.getGraphics();
g.drawImage(image, 0, 0, null);
g.drawImage(overlay, 0, 0, null);

// Save as new image
ImageIO.write(combined, "PNG", new File(path, "combined.png"));

Wednesday, 21 May 2014

Version 1.49a 15 May 2014

Version 1.49a  (upgrade)

  • Thanks to Kenneth Sloan, added a "Paint on overlay" option to the built in brush tool's options dialog. Add the built in brush tool to the toolbar by selecting "Brush" from the toolbar's ">>" menu.
  • Thanks to Daniel Pensold, Analyze>Tools>Save XY Coordinatessaves the coordinates and values of pixels inside selections to a .csv file.
  • Thanks to Volker Wirth, added a "Title:" field to the dialog displayed by Edit>Selection>Straighten when the line width is one or when processing a stack.
  • Selections created by the selection brush tool are deleted after they are added to an overlay.
  • Thanks to Jon Harman, Plugins>Install recognizes .zip files.
  • Thanks to Jerome Mutterer, added the makeArrow() macro function (example).
  • Thanks to Federico Luzzati, added the Stack.toggleChannel() macro function (example).
  • Thanks to Norbert Vischer, the showProgress(progress) macro function displays subordinate progress bars as moving dots when 'progress' is negative (macro example, script example).
  • Thanks to Messaoudi Cedric, Edit>Options>Memory & Threadsno longer limits the number of threads to 32.
  • Thanks to Wilhelm Burger, added the IJ.setProperty(String,Object) and IJ.getProperty(String) methods, which are useful for passing data between plugins.
  • Thanks to Stephan Preibisch, added the MultiLineLabel#setText() method (example).
  • Fixed a bug that caused the recording mode to not be saved when quitting ImageJ with the Recorder open.
  • Thanks to Mats Nilsson, fixed a bug that caused the getInfo() macro function and ImagePlus#getStringProperty() method to not work with DICOM tags containing letters.
  • Thanks to Norbert Vischer, fixed a bug the caused the Array.findMaxima() macro function to throw an exception when the array length was one.
  • Fixed a bug that caused images with overlays containing black transparent images to not be correctly saved and restored.
  • Thanks to Jan Brocher, fixed a v1.48 regression that caused changes made in the Image>Overlay>Add to Overlay dialog (displayed when you press alt+b) to not be remembered.
  • Thanks to Kees Straatman, fixed a bug that caused the recorder to incorrectly record the Process>Binary>Convert to Mask command.
  • Thanks to Chris Weisiger, fixed a bug in Image>Stacks>Othogonal Viewsthat caused it to fail with extened StackWindows with custom controls.
  • Thanks to Philippe Carl, fixed a v1.48t regression that caused the Plot#drawNormalizedLine() method to not work with log plots.


Thursday, 8 May 2014


ImageJ2 is a new version of ImageJ seeking to strengthen both the software and its community. Internally, it is a total redesign of ImageJ, but it is backwards compatible with ImageJ 1.x via a "legacy layer" and features a user interface closely modeled after the original.

Under the hood, ImageJ2 completely isolates the image processing logic from the graphical user interface (UI), allowing ImageJ2 commands to be used in many contexts, including headless in the cloud or on a server such as OMERO, or from within another application such as KNIME, Icy or CellProfiler (a Python application).

ImageJ2 has an N-dimensional data model driven by the powerful ImgLib2 library, which supports image data expressed in an extensible set of numeric and non-numeric types, and accessed from an extensible set of data sources. ImageJ2 is driven by a state-of-the-art, collaborative development process, including version control, unit testing, automated builds via a continuous integration system, a bug tracker and more.

We are collaborating closely with related projects including Fiji, SCIFIO and OME, and are striving to deliver a coherent software stack reusable throughout the life sciences community and beyond. For more details, see the SciJava web site.

ImageJ2 is currently in the "beta" stage, meaning the code is not finished. It is being released for early community feedback and testing. Comments, questions and bug reports are much appreciated!

To maintain ImageJ's continuity of development, we have modeled the application after ImageJ v1.x as much as is reasonable. However, please be aware that ImageJ2 is essentially a total rewrite of ImageJ from the ground up. It provides backward compatibility with older versions of ImageJ by bundling the latest v1.x code and translating between "legacy" and "modern" image structures.

For more details on the project, see the ImageJ2 web site.


ImageJ2 is distributed under a Simplified BSD License; for the full text of the license, see LICENSE.txt.
For the list of developers and contributors, see pom.xml.


This repository is the master ImageJ2 application, which brings together all of ImageJ under the artifact net.imagej:imagej. It is the easiest entry point if you are looking to use ImageJ as a library from your own software. E.g., in your Maven pom.xml:

We recommend inheriting from the pom-scijava parent, although it is not required. (If you do not, you will need to include the <version> of ImageJ in your <dependency> declaration.)


This component depends on other, lower level components, each of which lives in its own repository:
It also includes uses various "plugin" components at runtime:
See the pom.xml for a complete list of dependencies.


For a list of known issues, see the issue tracking system.
Please report any bugs by following the instructions online.

Wednesday, 7 May 2014

Version 1.48v 19 April 2014 (upgrade)

  •  Plot and Histogram windows are no longer centered on the screen.
  • Added the Overlay.clear and setOption("Add to overlay",boolean) macro functions.
  • Thanks to David Knecht, commands listed in the Plugins>Shortcuts>List Shortcuts and Plugins>Shortcuts>Create Shortcutdialogs are sorted with case ignored.
  • Thanks to Denis Roussel, changed an incorrect Javadoc reference in from SUPPORTS_STACKS to DOES_STACKS.
  • Thanks to Johannes Schindelin, added @link tags to the Javadocs.
  • Fixed a bug that caused the progress bar to not terminate after dragging a jar file to the "ImageJ" window.
  • Fixed a bug that caused the roiManager("add") macro function to unexpectedly set the stack position of the source selection. 

ImageJ Features

Runs Everywhere:
ImageJ is written in Java, which allows it to run on Linux, Mac OS X and Windows, in both 32-bit and 64-bit modes.
Open Source:
ImageJ and its Java source code are freely available and in the public domain. No license is required.
User Community:
ImageJ has a large and knowledgeable worldwide user community. More than 1700 users and developers subscribe to the ImageJ mailing list.
Automate tasks and create custom tools using macros. Generate macro code using the command recorder and debug it using the macro debugger. More than 300 macros are available on the ImageJ Web site.
Extend ImageJ by developing plugins using ImageJ's built in text editor and Java compiler. More than 500 plugins are available.
Use ImageJ as a image processing toolkit (class library) to develop applets, servlets or applications.
ImageJ is the world's fastest pure Java image processing program. It can filter a 2048x2048 image in 0.1 seconds (*). That's 40 million pixels per second!
Data Types:
8-bit grayscale or indexed color, 16-bit unsigned integer, 32-bit floating-point and RGB color.
File Formats:
Open and save all supported data types as TIFF (uncompressed) or as raw data. Open and save GIF, JPEG, BMP, PNG, PGM, FITS and ASCII. Open DICOM. Open TIFFs, GIFs, JPEGs, DICOMs and raw data using a URL. Open and save many other formats using plugins.
Image display:
Tools are provided for zooming (1:32 to 32:1) and scrolling images. All analysis and processing functions work at any magnification factor.
Create rectangular, elliptical or irregular area selections. Create line and point selections. Edit selections and automatically create them using the wand tool. Draw, fill, clear, filter or measure selections. Save selections and transfer them to other images.
Image Enhancement:
Supports smoothing, sharpening, edge detection, median filtering and thresholding on both 8-bit grayscale and RGB color images. Interactively adjust brightness and contrast of 8, 16 and 32-bit images.
Geometric Operations:
Crop, scale, resize and rotate. Flip vertically or horizontally.
Measure area, mean, standard deviation, min and max of selection or entire image. Measure lengths and angles. Use real world measurement units such as millimeters. Calibrate using density standards. Generate histograms and profile plots.
Cut, copy or paste images or selections. Paste using AND, OR, XOR or "Blend" modes. Add text, arrows, rectangles, ellipses or polygons to images.
Color Processing:
Split a 32-bit color image into RGB or HSV components. Merge 8-bit components into a color image. Convert an RGB image to 8-bit indexed color. Apply pseudo-color palettes to grayscale images.
Display a "stack" of related images in a single window. Process an entire stack using a single command. Open a folder of images as a stack. Save stacks as multi-image TIFF files.    

Intro to ImageJ

ImageJ is free public domain image processing software developed at the National Institutes of Health. Its power and flexibility allow it to be used as a research tool by scientists in many disciplines, from medicine to astronomy. Installers are available for Windows, MacOS and OSX, and Linux.
You can use ImageJ to display, annotate, edit, calibrate, measure, analyze, process, print, and save raster (row and column) image data. It reads most common raster image formats as well as raw data files in text format, such as from spreadsheets. ImageJ also supports stacks - multiple images in a single window - for animation and analysis.

ImageJ is a public domain Java image processing program inspired by NIH Image for the Macintosh. It runs, either as an online applet or as a downloadable application, on any computer with a Java 1.4 or later virtual machine. Downloadable distributions are availablefor Windows, Mac OS, Mac OS X and Linux.

It can display, edit, analyze, process, save and print 8-bit, 16-bit and 32-bit images. It can read many image formats including TIFF, GIF, JPEG, BMP, DICOM, FITS and "raw". It supports "stacks", a series of images that share a single window. It is multithreaded, so time-consuming operations such as image file reading can be performed in parallel with other operations.

It can calculate area and pixel value statistics of user-defined selections. It can measure distances and angles. It can create density histograms and line profile plots. It supports standard image processing functions such as contrast manipulation, sharpening, smoothing, edge detection and median filtering.

It does geometric transformations such as scaling, rotation and flips. Image can be zoomed up to 32:1 and down to 1:32. All analysis and processing functions are available at any magnification factor. The program supports any number of windows (images) simultaneously, limited only by available memory.

Spatial calibration is available to provide real world dimensional measurements in units such as millimeters. Density or gray scale calibration is also available.

ImageJ was designed with an open architecture that provides extensibility via Java plugins. Custom acquisition, analysis and processing plugins can be developed using ImageJ's built in editor and Java compiler. User-written plugins make it possible to solve almost any image processing or analysis problem.