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 PlugInFilter.java from SUPPORTS_STACKS to DOES_STACKS.
• Thanks to Johannes Schindelin, added @link tags to the PlugInFilter.java 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.

Macros:

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.

Plugins:

Extend ImageJ by developing plugins using ImageJ's built in text editor and Java compiler. More than 500 plugins are available.

Toolkit:

Use ImageJ as a image processing toolkit (class library) to develop applets, servlets or applications.

Speed:

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.

Selections:

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.

Analysis:

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.

Editing:

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.

Stacks:

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. 

Rotate Cross Lines With help Of Circle

                             

                                double radians = Math.atan2(event.getY() - osPoint.getCenterY(), event.getX()
- osPoint.getCenterX());

double degrees = Math.round((radians * 180 / Math.PI));

double rotation = degrees + 90;

osPoint.setRotate(osPoint.getRotate() + rotation);
osHline.setRotate(osHline.getRotate() + rotation);
osVline.setRotate(osVline.getRotate() + rotation);

java replaceFirst problem with $

Not here, it isn't. When calling replaceFirst() or replaceAll(), the first argument is a regular expression, which follows the rules of java regular expressions as described in java.util.regex.Pattern. But the second argument is not a regex; it's a replacement text - which has different rules. Quoting from the String.replaceFirst() API: "Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string; see Matcher.replaceFirst(java.lang.String). Use Matcher.quoteReplacement(java.lang.String) to suppress the special meaning of these characters, if desired."

If you follow the link to Matcher.replaceFirst() it refers you to Matcher.appendReplacement() which has more detail: "The replacement string may contain references to subsequences captured during the previous match: Each occurrence of $g will be replaced by the result of evaluating group(g). The first number after the $ is always treated as part of the group reference. Subsequent numbers are incorporated into g if they would form a legal group reference. Only the numerals '0' through '9' are considered as potential components of the group reference. If the second group matched the string "foo", for example, then passing the replacement string "$2bar" would cause "foobar" to be appended to the string buffer. A dollar sign ($) may be included as a literal in the replacement string by preceding it with a backslash (\$)."

In other words, $1 would be capture group 1, $6 would be capture group 6. $z doesn't make sense to the matcher - that's what "Illegal group reference" means here. Because z is not a group.

And to fix this problem, you can either do as EFJ showed, putting a double backslash in front of the $, or you can use Matcher.quoteReplacement() as suggested in the replaceFirst() API:

String y = Matcher.quoteReplacement("xy$z");

Now What we do in this case : String x ="${data} m,.m,.m,";

So the solution is :

        String x ="${data} m,.m,.m,";
        String y = x.replaceFirst("\\$\\{data\\}", "Amaan");
        System.out.println(y); 

Delete particular folder base don Time Criteria

package Bean;

import java.io.File;
import java.util.Calendar;

public class DeleteDir {

    private static void autoDeleteFileAndDir(String filePath, Integer hours,
            Integer minutes) {
        Long timeDiff;
        if (filePath != null && !filePath.isEmpty()
                && (hours != null || minutes != null)) {
            if(hours!=null&&hours>0){
                timeDiff= (long) (hours*60 * 60 * 1000);
            }else {
                timeDiff= (long) (minutes * 60 * 1000);
            }
           
            File file = new File(filePath);

            System.out
            .println("Now will search folders and delete files in :: ,\nFile path :: "
                    + file.getAbsolutePath());
           
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    if (f.isDirectory()) {
                        Long FileTimeDiff = (Calendar.getInstance().getTime().getTime() - f
                                .lastModified());
                       
                        System.out.println("\n\nf.lastModified() :: "
                                + f.lastModified()
                                + "\nnew Date().getDate() :: "
                                + Calendar.getInstance().getTime().getTime() + "\nDiff :: "
                                + FileTimeDiff);
                       
                        if (FileTimeDiff > timeDiff) {
                            if (f.delete()) {
                       
                                System.out.println("\n\n" + f.getName()
                                        + ":: Dir deleted!!!!!");
                               
                            }
                        } else {
                           
                            System.out.println("\n\n" + f.getName()
                                    + ":: Dir not deleted!!!!!");
                           
                        }
                    }
                }
            }
           
        }else {
            System.out.println("Invalid parameter");
        }
       
    }

The Spiral Model

The spiral model, originally proposed by Boehm , is an evolutionary software

process model that couples the iterative nature of prototyping with the controlled and

systematic aspects of the linear sequential model. It provides the potential for rapid

development of incremental versions of the software. Using the spiral model, software

is developed in a series of incremental releases. During early iterations, the

incremental release might be a paper model or prototype. During later iterations,

increasingly more complete versions of the engineered system are produced.

A spiral model is divided into a number of framework activities, also called task

regions.6 Typically, there are between three and six task regions. A spiral model

 that contains six task regions:

• Customer communication—tasks required to establish effective communication

between developer and customer.

• Planning—tasks required to define resources, timelines, and other projectrelated

information.

• Risk analysis—tasks required to assess both technical and management

risks.

• Engineering—tasks required to build one or more representations of the

application.

• Construction and release—tasks required to construct, test, install, and

provide user support (e.g., documentation and training).

• Customer evaluation—tasks required to obtain customer feedback based

on evaluation of the software representations created during the engineering

stage and implemented during the installation stage.

Each of the regions is populated by a set of work tasks, called a task set, that are

adapted to the characteristics of the project to be undertaken. For small projects, the

number of work tasks and their formality is low. For larger, more critical projects,

each task region contains more work tasks that are defined to achieve a higher level

of formality

.

As this evolutionary process begins, the software engineering team moves around

the spiral in a clockwise direction, beginning at the center. The first circuit around

the spiral might result in the development of a product specification; subsequent

passes around the spiral might be used to develop a prototype and then progressively

more sophisticated versions of the software. Each pass through the planning region

results in adjustments to the project plan. Cost and schedule are adjusted based on

feedback derived from customer evaluation. In addition, the project manager adjusts

the planned number of iterations required to complete the software.

Unlike classical process models that end when software is delivered, the spiral

model can be adapted to apply throughout the life of the computer software. An alternative

view of the spiral model can be considered by examining the project entry point

axis. Each cube placed along the axis can be used to represent

the starting point for different types of projects. A “concept development

project” starts at the core of the spiral and will continue (multiple iterations occur

along the spiral path that bounds the central shaded region) until concept development

is complete. If the concept is to be developed into an actual product, the process

proceeds through the next cube (new product development project entry point) and

a “new development project” is initiated. The new product will evolve through a number

of iterations around the spiral, following the path that bounds the region that has

somewhat lighter shading than the core. In essence, the spiral, when characterized

in this way, remains operative until the software is retired. There are times when the

process is dormant, but whenever a change is initiated, the process starts at the appropriate

entry point .

The spiral model is a realistic approach to the development of large-scale systems

and software. Because software evolves as the process progresses, the developer and

customer better understand and react to risks at each evolutionary level. The spiral model

uses prototyping as a risk reduction mechanism but, more important, enables the developer

to apply the prototyping approach at any stage in the evolution of the product. It

maintains the systematic stepwise approach suggested by the classic life cycle but incorporates

it into an iterative framework that more realistically reflects the real world. The

spiral model demands a direct consideration of technical risks at all stages of the project

and, if properly applied, should reduce risks before they become problematic.

But like other paradigms, the spiral model is not a panacea. It may be difficult to

convince customers (particularly in contract situations) that the evolutionary approach

is controllable. It demands considerable risk assessment expertise and relies on this

expertise for success. If a major risk is not uncovered and managed, problems will

undoubtedly occur. Finally, the model has not been used as widely as the linear

sequential or prototyping paradigms. It will take a number of years before efficacy of

this important paradigm can be determined with absolute certainty.